Rename cold start to VM snapshot, add user area

fwsGonzo · fwsGonzo · commit 645547006719 · 2025-10-17T09:38:56.000+02:00
diff --git a/lib/tinykvm/common.hpp b/lib/tinykvm/common.hpp
@@ -96,10 +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
+		/* Enable VM snapshot 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;
+		std::string snapshot_file;
 		/* When using hugepages, cover the given size with
 		   hugepages, unless 0, in which case the entire
 		   main memory will be covered. */
diff --git a/lib/tinykvm/machine.cpp b/lib/tinykvm/machine.cpp
@@ -38,8 +38,8 @@ 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");
+	if (options.mmap_backed_files && !options.snapshot_file.empty()) {
+		throw MachineException("Cannot have VM snapshot with mmap-backed files at the same time");
 	}
 
 	this->fd = create_kvm_vm();
@@ -48,9 +48,12 @@ Machine::Machine(std::string_view binary, const MachineOptions& options)
 
 	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");
+	if (memory.has_loadable_snapshot_state()) {
+		this->m_loaded_from_snapshot = this->load_snapshot_state();
+		if (this->m_loaded_from_snapshot) {
+			if (options.verbose_loader) {
+				printf("Loaded VM snapshot state\n");
+			}
 			return;
 		}
 		// If the file does not exist, or anything else failed, we continue
diff --git a/lib/tinykvm/machine.hpp b/lib/tinykvm/machine.hpp
@@ -298,7 +298,12 @@ struct Machine
 	/* 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;
+	void save_snapshot_state_now() const;
+	/* Check if the VM was loaded from a snapshot state. */
+	bool has_snapshot_state() const noexcept { return m_loaded_from_snapshot; }
+	/* Get pointer to user area in snapshot state memory, or nullptr
+	   if no snapshot state is present. */
+	void* get_snapshot_state_user_area() const;
 
 	static void init();
 	static void setup_linux_system_calls(bool unsafe_syscalls = false);
@@ -326,13 +331,14 @@ 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();
+	bool load_snapshot_state();
 
 	vCPU  vcpu;
 	int   fd = 0;
 	bool  m_prepped = false;
 	bool  m_forked = false;
 	bool  m_just_reset = false;
+	bool  m_loaded_from_snapshot = false;
 	bool  m_remote_pfaults = false;
 	bool  m_permanent_remote_connection = false;
 	bool  m_relocate_fixed_mmap = false;
diff --git a/lib/tinykvm/machine_state.cpp b/lib/tinykvm/machine_state.cpp
@@ -50,10 +50,10 @@ struct ColdStartSocketPair {
 	int type;
 };
 
-struct ColdStartState {
+struct SnapshotState {
 	static constexpr uint32_t MAGIC = 0x564D4353; // 'VMCS'
 	uint32_t magic;
-	uint32_t version;
+	uint32_t size;
 	tinykvm_x86regs    regs;
 	kvm_sregs          sregs;
 	tinykvm_x86fpuregs fpu;
@@ -83,31 +83,29 @@ struct ColdStartState {
 		current = reinterpret_cast<char*>(current) + sizeof(T);
 		// Bounds-check against end-of-structure
 		if (reinterpret_cast<char*>(current) > reinterpret_cast<char*>(this) + Size()) {
-			throw std::runtime_error("Out of bounds access on ColdStartState");
+			throw std::runtime_error("Out of bounds access on SnapshotState");
 		}
 		return ret;
 	}
 };
-bool Machine::load_cold_start_state()
+bool Machine::load_snapshot_state()
 {
-	if (!memory.has_loadable_cold_start_state()) {
+	if (!memory.has_loadable_snapshot_state()) {
 		return false;
 	}
-	if (!this->memory.has_cold_start_area) {
-		throw std::runtime_error("No cold start state area allocated");
+	if (!this->memory.has_snapshot_area) {
+		throw std::runtime_error("No snapshot state area allocated");
 	}
 	if (this->is_forked()) {
-		throw std::runtime_error("Cannot load cold start state into a forked VM");
+		throw std::runtime_error("Cannot load snapshot state into a forked VM");
 	}
-	void* map = this->memory.get_cold_start_state_area();
-	ColdStartState& state = *reinterpret_cast<ColdStartState*>(map);
-	if (state.magic != ColdStartState::MAGIC) {
-		throw std::runtime_error("No valid cold start state found");
+	void* map = this->memory.get_snapshot_state_area();
+	SnapshotState& state = *reinterpret_cast<SnapshotState*>(map);
+	if (state.magic != SnapshotState::MAGIC) {
+		throw std::runtime_error("No valid snapshot state found");
 	}
-	if (state.version != 1) {
-		fprintf(stderr, "Warning: Cold start state version mismatch: %u != %u\n",
-			state.version, 1u);
-		return false;
+	if (state.size < sizeof(SnapshotState) || state.size > SnapshotState::Size()) {
+		throw std::runtime_error("Invalid snapshot state size");
 	}
 
 	// Load the state into the VM
@@ -130,7 +128,7 @@ bool Machine::load_cold_start_state()
 		this->memory.main_memory_writes = state.main_memory_writes;
 		this->memory.page_tables = state.m_page_tables;
 
-		void* current = reinterpret_cast<char*>(&state) + sizeof(ColdStartState);
+		void* current = reinterpret_cast<char*>(&state) + sizeof(SnapshotState);
 		// Load the thread states
 		ColdStartThreads* threads = state.next<ColdStartThreads>(current);
 		if (threads->count > 0) {
@@ -178,16 +176,16 @@ bool Machine::load_cold_start_state()
 	}
 	return true;
 }
-void Machine::save_cold_start_state_now() const
+void Machine::save_snapshot_state_now() const
 {
 	if (this->is_forked()) {
-		throw std::runtime_error("Cannot save cold start state of a forked VM");
+		throw std::runtime_error("Cannot save snapshot state of a forked VM");
 	}
-	void* map = this->memory.get_cold_start_state_area();
-	ColdStartState& state = *reinterpret_cast<ColdStartState*>(map);
+	void* map = this->memory.get_snapshot_state_area();
+	SnapshotState& state = *reinterpret_cast<SnapshotState*>(map);
 	try {
-		state.magic = ColdStartState::MAGIC;
-		state.version = 1;
+		state.magic = SnapshotState::MAGIC;
+		state.size  = 0; // Invalid (for now)
 		state.regs  = this->registers();
 		state.sregs = this->get_special_registers();
 		state.fpu   = this->fpu_registers();
@@ -206,7 +204,7 @@ void Machine::save_cold_start_state_now() const
 		state.main_memory_writes = this->memory.main_memory_writes;
 		state.m_page_tables = this->memory.page_tables;
 
-		void* current = reinterpret_cast<char*>(&state) + sizeof(ColdStartState);
+		void* current = reinterpret_cast<char*>(&state) + sizeof(SnapshotState);
 		// Save the multi-threading state
 		ColdStartThreads* threads = state.next<ColdStartThreads>(current);
 		if (this->has_threads()) {
@@ -262,27 +260,50 @@ void Machine::save_cold_start_state_now() const
 			csp->type = int(sp.type);
 		}
 
+		// Finally, set the size
+		state.size = static_cast<uint32_t>(
+			reinterpret_cast<char*>(current) - reinterpret_cast<char*>(&state));
+		if (state.size < sizeof(SnapshotState) || state.size > SnapshotState::Size()) {
+			throw std::runtime_error("Snapshot state size was invalid");
+		}
+
 	} catch (const MachineException& me) {
 		throw std::runtime_error(std::string("Failed to get cold start state: ") + me.what());
 	}
 }
 
-void* vMemory::get_cold_start_state_area() const
+void* vMemory::get_snapshot_state_area() const
 {
-	if (!this->has_cold_start_area) {
+	if (!this->has_snapshot_area) {
 		throw std::runtime_error("No cold start state area allocated");
 	}
 	// The cold start state area is after the end of the memory
 	return (void*)(this->ptr + this->size);
 }
-bool vMemory::has_loadable_cold_start_state() const noexcept
+bool vMemory::has_loadable_snapshot_state() const noexcept
 {
-	if (this->has_cold_start_area) {
-		void* area = this->get_cold_start_state_area();
+	if (this->has_snapshot_area) {
+		void* area = this->get_snapshot_state_area();
 		uint32_t* magic = reinterpret_cast<uint32_t*>(area);
-		return *magic == ColdStartState::MAGIC;
+		return *magic == SnapshotState::MAGIC;
 	}
 	return false;
 }
+void* Machine::get_snapshot_state_user_area() const
+{
+	if (!this->memory.has_snapshot_area) {
+		return nullptr;
+	}
+	void* map = this->memory.get_snapshot_state_area();
+	SnapshotState& state = *reinterpret_cast<SnapshotState*>(map);
+	if (state.magic != SnapshotState::MAGIC) {
+		return nullptr;
+	}
+	if (state.size < sizeof(SnapshotState) || state.size > SnapshotState::Size()) {
+		return nullptr;
+	}
+	// The user area is after the SnapshotState + size
+	return reinterpret_cast<char*>(map) + sizeof(SnapshotState) + state.size;
+}
 
 } // namespace tinykvm
diff --git a/lib/tinykvm/memory.cpp b/lib/tinykvm/memory.cpp
@@ -26,7 +26,7 @@ vMemory::vMemory(Machine& m, const MachineOptions& options,
 	: machine(m), physbase(ph), safebase(sf),
 	  // Over-allocate in order to avoid trouble with 2MB-aligned operations
 	  ptr(p), size(overaligned_memsize(s)), owned(own),
-	  has_cold_start_area(own && !options.fast_cold_start_file.empty()),
+	  has_snapshot_area(own && !options.snapshot_file.empty()),
 	  main_memory_writes(options.master_direct_memory_writes),
 	  split_hugepages(options.split_hugepages),
 	  executable_heap(options.executable_heap),
@@ -393,35 +393,35 @@ vMemory::AllocationResult
 	// Add the cold start state area
 	size += ColdStartStateSize();
 	// Open the to-be memory-mapped file
-	const std::string& filename = options.fast_cold_start_file;
+	const std::string& filename = options.snapshot_file;
 	if (filename.empty()) {
-		throw std::runtime_error("No fast cold start file specified");
+		throw std::runtime_error("No VM snapshot file specified");
 	}
 	const int fd = open(filename.c_str(), O_RDWR | O_CREAT | O_CLOEXEC, 0600);
 	if (fd < 0) {
-		throw std::runtime_error("Failed to open fast cold start file: " + filename);
+		throw std::runtime_error("Failed to open VM snapshot file: " + filename);
 	}
 	struct stat st;
 	if (fstat(fd, &st) != 0) {
 		close(fd);
-		throw std::runtime_error("Failed to stat fast cold start file: " + filename);
+		throw std::runtime_error("Failed to stat VM snapshot file: " + filename);
 	}
 	if (st.st_size != off_t(size)) {
 		if (st.st_size != 0) {
 			close(fd);
-			throw std::runtime_error("Fast cold start file has incorrect size: " + filename);
+			throw std::runtime_error("VM snapshot file has incorrect size: " + filename);
 		}
 		// Create the file with the correct size
 		if (ftruncate(fd, size) != 0) {
 			close(fd);
-			throw std::runtime_error("Failed to set size of fast cold start file: " + filename);
+			throw std::runtime_error("Failed to set size of VM snapshot file: " + filename);
 		}
 	}
 	char* ptr = (char*) mmap(NULL, size, PROT_READ | PROT_WRITE,
 		MAP_SHARED | MAP_NORESERVE, fd, 0);
 	close(fd);
 	if (ptr == MAP_FAILED) {
-		memory_exception("Failed to mmap fast cold start file", 0, size);
+		memory_exception("Failed to mmap VM snapshot file", 0, size);
 	}
 	return AllocationResult{ptr, size - ColdStartStateSize()};
 }
@@ -434,7 +434,7 @@ vMemory vMemory::New(Machine& m, const MachineOptions& options,
 	// Over-allocate in order to avoid trouble with 2MB-aligned operations
 	size = vMemory::overaligned_memsize(size);
 	// Use file-backed memory if requested
-	if (!options.fast_cold_start_file.empty()) {
+	if (!options.snapshot_file.empty()) {
 		const auto [res_ptr, res_size] = allocate_filebacked_memory(options, size);
 		return vMemory(m, options, phys, safe, res_ptr, res_size);
 	}
diff --git a/lib/tinykvm/memory.hpp b/lib/tinykvm/memory.hpp
@@ -28,7 +28,7 @@ struct vMemory {
 	char*  ptr;
 	size_t size;
 	bool   owned = true;
-	bool   has_cold_start_area = false;
+	bool   has_snapshot_area = false;
 	/* Remote end pointer for this memory */
 	uint64_t remote_end = 0;
 	bool     remote_must_update_gigapages = true;
@@ -113,8 +113,8 @@ struct vMemory {
 	static size_t ColdStartStateSize() {
 		return 2UL << 20; // 2MB
 	}
-	bool has_loadable_cold_start_state() const noexcept;
-	void* get_cold_start_state_area() const;
+	bool has_loadable_snapshot_state() const noexcept;
+	void* get_snapshot_state_area() const;
 private:
 	using AllocationResult = std::tuple<char*, size_t>;
 	static AllocationResult allocate_mapped_memory(const MachineOptions&, size_t size);
