Load existing snapshots with private read-only mappings

Author: fwsGonzo

lib/tinykvm/machine_state.cpp

@@ -94,7 +94,7 @@ bool Machine::load_snapshot_state()
 	if (!memory.has_loadable_snapshot_state()) {
 		return false;
 	}
-	if (!this->memory.has_snapshot_area) {
+	if (!this->memory.has_snapshot_area()) {
 		throw std::runtime_error("No snapshot state area allocated");
 	}
 	if (this->is_forked()) {
@@ -280,15 +280,15 @@ void Machine::save_snapshot_state_now() const
 
 void* vMemory::get_snapshot_state_area() const
 {
-	if (!this->has_snapshot_area) {
+	if (!this->has_snapshot_area()) {
 		throw std::runtime_error("No snapshot state area allocated");
 	}
 	// The snapshot state area is after the end of the memory
 	return (void*)(this->ptr + this->size);
 }
 bool vMemory::has_loadable_snapshot_state() const noexcept
 {
-	if (this->has_snapshot_area) {
+	if (this->has_snapshot_area()) {
 		void* area = this->get_snapshot_state_area();
 		uint32_t* magic = reinterpret_cast<uint32_t*>(area);
 		return *magic == SnapshotState::MAGIC;
@@ -297,7 +297,7 @@ bool vMemory::has_loadable_snapshot_state() const noexcept
 }
 void* Machine::get_snapshot_state_user_area() const
 {
-	if (!this->memory.has_snapshot_area) {
+	if (!this->memory.has_snapshot_area()) {
 		return nullptr;
 	}
 	void* map = this->memory.get_snapshot_state_area();

lib/tinykvm/memory.cpp

@@ -22,11 +22,11 @@ namespace tinykvm {
 static constexpr bool VERBOSE_MMAP = false;
 
 vMemory::vMemory(Machine& m, const MachineOptions& options,
-	uint64_t ph, uint64_t sf, char* p, size_t s, bool own)
+	uint64_t ph, uint64_t sf, char* p, size_t s, int fd, bool own)
 	: 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_snapshot_area(own && !options.snapshot_file.empty()),
+	  ptr(p), size(overaligned_memsize(s)),
+	  owned(own), snapshot_fd(fd),
 	  main_memory_writes(options.master_direct_memory_writes),
 	  split_hugepages(options.split_hugepages),
 	  executable_heap(options.executable_heap),
@@ -55,7 +55,7 @@ vMemory::vMemory(Machine& m, const MachineOptions& options,
 	}
 }
 vMemory::vMemory(Machine& m, const MachineOptions& options, const vMemory& other)
-	: vMemory{m, options, other.physbase, other.safebase, other.ptr, other.size, false}
+	: vMemory{m, options, other.physbase, other.safebase, other.ptr, other.size, -1, false}
 {
 	this->executable_heap = other.executable_heap;
 	this->mmap_physical_begin = other.mmap_physical_begin;
@@ -379,7 +379,7 @@ vMemory::AllocationResult vMemory::allocate_mapped_memory(
 	if (advice != 0x0) {
 		madvise(ptr, size, advice);
 	}
-	return AllocationResult{ptr, size};
+	return AllocationResult{ptr, size, -1};
 }
 vMemory::AllocationResult
 	vMemory::allocate_filebacked_memory(const MachineOptions& options, size_t size)
@@ -406,7 +406,10 @@ vMemory::AllocationResult
 		close(fd);
 		throw std::runtime_error("Failed to stat VM snapshot file: " + filename);
 	}
-	if (st.st_size != off_t(size)) {
+	bool already_right_size = (st.st_size == off_t(size));
+	char* ptr = (char*)MAP_FAILED;
+	// If the file is not the correct size, resize it
+	if (!already_right_size) {
 		if (st.st_size != 0) {
 			close(fd);
 			throw std::runtime_error("VM snapshot file has incorrect size: " + filename);
@@ -416,14 +419,18 @@ vMemory::AllocationResult
 			close(fd);
 			throw std::runtime_error("Failed to set size of VM snapshot file: " + filename);
 		}
+		ptr = (char*) mmap(NULL, size, PROT_READ | PROT_WRITE,
+			MAP_SHARED | MAP_NORESERVE, fd, 0);
+	} else {
+		// Map an existing file, which should not be modified on disk
+		ptr = (char*) mmap(NULL, size, PROT_READ | PROT_WRITE,
+			MAP_PRIVATE | MAP_NORESERVE, fd, 0);
 	}
-	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 VM snapshot file", 0, size);
 	}
-	return AllocationResult{ptr, size - ColdStartStateSize()};
+	return AllocationResult{ptr, size - ColdStartStateSize(), fd};
 }
 
 vMemory vMemory::New(Machine& m, const MachineOptions& options,
@@ -435,12 +442,12 @@ vMemory vMemory::New(Machine& m, const MachineOptions& options,
 	size = vMemory::overaligned_memsize(size);
 	// Use file-backed memory if requested
 	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);
+		const auto [res_ptr, res_size, fd] = allocate_filebacked_memory(options, size);
+		return vMemory(m, options, phys, safe, res_ptr, res_size, fd);
 	}
 	// Normal 2MB main memory allocation
-	const auto [res_ptr, res_size] = allocate_mapped_memory(options, size);
-	return vMemory(m, options, phys, safe, res_ptr, res_size);
+	const auto [res_ptr, res_size, fd] = allocate_mapped_memory(options, size);
+	return vMemory(m, options, phys, safe, res_ptr, res_size, -1);
 }
 
 VirtualMem vMemory::vmem() const

lib/tinykvm/memory.hpp

@@ -28,7 +28,7 @@ struct vMemory {
 	char*  ptr;
 	size_t size;
 	bool   owned = true;
-	bool   has_snapshot_area = false;
+	int    snapshot_fd = -1;
 	/* Remote end pointer for this memory */
 	uint64_t remote_end = 0;
 	bool     remote_must_update_gigapages = true;
@@ -97,7 +97,7 @@ struct vMemory {
 	uint64_t expectedUsermodeFlags() const noexcept;
 
 	/* Create new identity-mapped memory regions */
-	vMemory(Machine&, const MachineOptions&, uint64_t, uint64_t, char*, size_t, bool = true);
+	vMemory(Machine&, const MachineOptions&, uint64_t, uint64_t, char*, size_t, int fd, bool own = true);
 	unsigned allocate_region_idx();
 	void install_mmap_ranges(const Machine& other);
 	void delete_foreign_mmap_ranges();
@@ -115,8 +115,14 @@ struct vMemory {
 	}
 	bool has_loadable_snapshot_state() const noexcept;
 	void* get_snapshot_state_area() const;
+	int get_snapshot_memory_fd() const noexcept {
+		return snapshot_fd;
+	}
+	bool has_snapshot_area() const noexcept {
+		return snapshot_fd != -1;
+	}
 private:
-	using AllocationResult = std::tuple<char*, size_t>;
+	using AllocationResult = std::tuple<char*, size_t, int>;
 	static AllocationResult allocate_mapped_memory(const MachineOptions&, size_t size);
 	static AllocationResult allocate_filebacked_memory(const MachineOptions&, size_t size);
 	std::vector<unsigned> m_bank_idx_free_list;