Add main VM CoW-mode test, with memory limits

Author: fwsGonzo

lib/tinykvm/threads.cpp

@@ -66,7 +66,9 @@ void Thread::exit()
 	if (this->clear_tid) {
 		THPRINT("Clearing thread value for tid=%d at 0x%lX\n",
 				this->tid, this->clear_tid);
-		*(uint32_t*) mt.machine.rw_memory_at(this->clear_tid, 4) = 0;
+		// clear the thread id in the parent
+		const uint32_t value = 0;
+		mt.machine.copy_to_guest(this->clear_tid, &value, sizeof(value));
 	}
 	auto& thr = this->mt;
 	// delete this thread
@@ -130,11 +132,13 @@ Thread& MultiThreading::create(
 	}
 	if (flags & CLONE_CHILD_SETTID) {
 		THPRINT("CHILD_SETTID at 0x%lX\n", ctid);
-		*(uint32_t*) machine.rw_memory_at(ctid, 4) = tid;
+		// set the thread id in the child
+		machine.copy_to_guest(ctid, &tid, sizeof(tid));
 	}
 	if (flags & CLONE_PARENT_SETTID) {
 		THPRINT("PARENT_SETTID at 0x%lX\n", ptid);
-		*(uint32_t*) machine.rw_memory_at(ptid, 4) = tid;
+		// set the thread id in the parent
+		machine.copy_to_guest(ptid, &tid, sizeof(tid));
 	}
 	if (flags & CLONE_CHILD_CLEARTID) {
 		THPRINT("CHILD_CLEARTID at 0x%lX\n", ctid);
@@ -304,11 +308,12 @@ void Machine::setup_multithreading()
 			const auto futex_op = regs.rsi;
 			const uint32_t val = regs.rdx;
 			THPRINT("Futex on: 0x%llX  val=%d\n", regs.rdi, val);
-			auto* fx = cpu.machine().template rw_memory_at<uint32_t>(addr, 4);
 
 			if ((futex_op & 0xF) == FUTEX_WAIT || (futex_op & 0xF) == FUTEX_WAIT_BITSET) {
-				THPRINT("FUTEX: Waiting for unlock... uaddr=%u val=%u\n", *fx, val);
-				if (*fx == val) {
+				uint32_t futexVal;
+				cpu.machine().copy_from_guest(&futexVal, addr, sizeof(futexVal));
+				THPRINT("FUTEX: Waiting for unlock... uaddr=%u val=%u\n", futexVal, val);
+				if (futexVal == val) {
 					if (cpu.machine().threads().suspend_and_yield()) {
 						return;
 					}

tests/unit/fork.cpp

@@ -359,3 +359,93 @@ extern void crash() {
 		}());
 	}
 }
+
+TEST_CASE("Fork and run main()", "[Fork]")
+{
+	const auto binary = build_and_load(R"M(
+int main() {
+	return 666;
+}
+static unsigned value = 12345;
+void set_value(int v) {
+	value = v;
+}
+int func1() {
+	return value;
+}
+int func2() {
+	return 54321;
+}
+)M");
+
+	tinykvm::Machine machine { binary, { .max_mem = MAX_MEMORY } };
+
+	// We need to create a Linux environment for runtimes to work well
+	machine.setup_linux({"fork"}, env);
+	REQUIRE(machine.banked_memory_pages() == 0);
+
+	// Make machine forkable (with *NO* working memory)
+	machine.prepare_copy_on_write(4ULL << 20);
+	REQUIRE(machine.is_forkable());
+	REQUIRE(!machine.is_forked());
+	REQUIRE(machine.return_value() == 0); // Initial register value
+
+	// Run for at most 4 seconds before giving up
+	machine.run(4.0f);
+	REQUIRE(machine.return_value() == 666); // Main() return value
+
+	// We only gave it 4MB working memory, so lets mmap allocate that and verify
+	// that if we write more than that, we get an exception thrown
+	REQUIRE_THROWS([&] () {
+		const size_t size = 5ULL << 20;
+		uint64_t addr = machine.mmap_allocate(5ULL << 20);
+		char buffer[4096];
+		for (int i = 0; i < 4096; i++)
+			buffer[i] = 'a';
+		for (size_t i = 0; i < size; i += 4096)
+		{
+			machine.copy_to_guest(addr + i, buffer, 4096);
+		}
+		// Unreachable
+		abort();
+	}());
+
+	// There are banked pages now
+	const auto banked_pages_before = machine.banked_memory_pages();
+	REQUIRE(banked_pages_before > 500);
+
+	// Create fork
+	auto fork1 = tinykvm::Machine { machine, {
+		.max_mem = MAX_MEMORY, .max_cow_mem = MAX_COWMEM
+	} };
+	REQUIRE(fork1.return_value() == 666); // Main() return value
+
+	fork1.vmcall("func1");
+	REQUIRE(fork1.return_value() == 12345);
+
+	fork1.vmcall("func2");
+	REQUIRE(fork1.return_value() == 54321);
+
+	// This is problematic, but we will try to fix this later
+	// Forked VM is supposed to diverge from the main VM, regardless of mode
+	machine.vmcall("set_value", 99999);
+	fork1.vmcall("func1");
+	REQUIRE(fork1.return_value() == 99999);
+
+	REQUIRE(machine.banked_memory_pages() == banked_pages_before);
+	REQUIRE(fork1.banked_memory_pages() > 0);
+
+	for (int i = 0; i < 20; i++)
+	{
+		fork1.reset_to(machine, {
+			.max_mem = MAX_MEMORY,
+			.max_cow_mem = MAX_COWMEM,
+		});
+
+		fork1.vmcall("func1");
+		REQUIRE(fork1.return_value() == 99999);
+
+		fork1.vmcall("func2");
+		REQUIRE(fork1.return_value() == 54321);
+	}
+}