Automatically select appropriate entry function

Author: fwsGonzo

lib/tinykvm/machine.cpp

@@ -28,6 +28,7 @@ namespace tinykvm {
 __attribute__ ((cold))
 Machine::Machine(std::string_view binary, const MachineOptions& options)
 	: m_forked {false},
+	  m_just_reset {false},
 	  m_binary {binary},
 	  memory { vMemory::New(*this, options,
 	  	options.vmem_base_address, options.vmem_base_address + 0x100000, options.max_mem)
@@ -55,6 +56,7 @@ Machine::Machine(const std::vector<uint8_t>& bin, const MachineOptions& opts)
 Machine::Machine(const Machine& other, const MachineOptions& options)
 	: m_prepped {false},
 	  m_forked  {true},
+	  m_just_reset {true},
 	  m_binary {options.binary.empty() ? other.m_binary : options.binary},
 	  memory   {*this, options, other.memory},
 	  m_stack_address {other.m_stack_address},
@@ -131,6 +133,7 @@ void Machine::reset_to(const Machine& other, const MachineOptions& options)
 		memory.fork_reset(options);
 	}
 
+	this->m_just_reset = true;
 	this->m_mm = other.m_mm;
 	this->m_mmap_cache = other.m_mmap_cache;
 

lib/tinykvm/machine.hpp

@@ -37,11 +37,6 @@ struct Machine
 	void timed_vmcall(address_t, float timeout, Args&&...);
 	template <typename... Args> constexpr
 	void timed_vmcall_stack(address_t, address_t stk, float timeout, Args&&...);
-	/* SYSV function call with timeout, no cache flushing */
-	template <typename... Args> constexpr
-	void timed_reentry(address_t, float timeout, Args&&...);
-	template <typename... Args> constexpr
-	void timed_reentry_stack(address_t, address_t stk, float timeout, Args&&...);
 	/* Retrieve optional return value from a vmcall */
 	long return_value() const;
 
@@ -230,6 +225,7 @@ struct Machine
 	int   fd = 0;
 	bool  m_prepped = false;
 	bool  m_forked = false;
+	bool  m_just_reset = false;
 	void* m_userdata = nullptr;
 
 	std::string_view m_binary;

lib/tinykvm/machine_inline.hpp

@@ -52,8 +52,13 @@ void Machine::setup_call(tinykvm_x86regs& regs,
 	regs = {};
 	/* Set IOPL=3 to allow I/O instructions in usermode */
 	regs.rflags = 2 | (3 << 12);
-	regs.r15 = addr;
-	regs.rip = this->entry_address();
+	if (this->m_just_reset) {
+		this->m_just_reset = false;
+		regs.r15 = addr;
+		regs.rip = this->entry_address();
+	} else {
+		regs.rip = addr;
+	}
 	regs.rsp = rsp;
 	[[maybe_unused]] unsigned iargs = 0;
 	([&] {
@@ -142,29 +147,6 @@ void Machine::timed_vmcall_stack(uint64_t addr, uint64_t stk, float timeout, Arg
 	this->run(timeout);
 }
 
-template <typename... Args> inline constexpr
-void Machine::timed_reentry(uint64_t addr, float timeout, Args&&... args)
-{
-	auto& regs = vcpu.registers();
-	this->setup_call(regs, addr,
-		this->stack_address(), std::forward<Args> (args)...);
-	/// This may jump directly to the guest function if DPL=3
-	regs.rip = this->reentry_address();
-	vcpu.set_registers(regs);
-	this->run(timeout);
-}
-
-template <typename... Args> inline constexpr
-void Machine::timed_reentry_stack(uint64_t addr, uint64_t stk, float timeout, Args&&... args)
-{
-	auto& regs = vcpu.registers();
-	this->setup_call(regs, addr, stk, std::forward<Args> (args)...);
-	/// This may jump directly to the guest function if DPL=3
-	regs.rip = this->reentry_address();
-	vcpu.set_registers(regs);
-	this->run(timeout);
-}
-
 inline uint64_t Machine::stack_push(__u64& sp, const std::string& string)
 {
 	return stack_push(sp, string.data(), string.size()+1); /* zero */

lib/tinykvm/vcpu.cpp

@@ -446,7 +446,7 @@ Machine::address_t Machine::entry_address() const noexcept {
 	return usercode_header().translated_vm_entry(memory);
 }
 Machine::address_t Machine::reentry_address() const noexcept {
-	return usercode_header().translated_vm_reentry(memory);
+	return usercode_header().translated_vm_userentry(memory);
 }
 Machine::address_t Machine::exit_address() const noexcept {
 	return usercode_header().translated_vm_rexit(memory);

src/bench.cpp

@@ -114,12 +114,12 @@ int main(int argc, char** argv)
 			printf("set_registers() average time: %lu nanos\n", set_registers_time);
 
 			auto fastest_call_time = micro_benchmark([&] {
-				master_vm.timed_reentry(vmcall_address, 0.0f);
+				master_vm.timed_vmcall(vmcall_address, 0.0f);
 			});
 			printf("Fastest possible vmcall time: %lu ns\n", fastest_call_time);
 
 			auto fastest_timed_call_time = micro_benchmark([&] {
-				master_vm.timed_reentry(vmcall_address, 4.0f);
+				master_vm.timed_vmcall(vmcall_address, 4.0f);
 			});
 			printf("Fastest possible timed vmcall time: %lu ns\n", fastest_timed_call_time);
 
@@ -504,7 +504,7 @@ void benchmark_multiple_vms(tinykvm::Machine& master_vm, size_t NUM, size_t RESE
 		if constexpr (FULL_RESET) {
 			fvm[counter].timed_vmcall(vmcall_address, 4.0f);
 		} else {
-			fvm[counter].timed_reentry(vmcall_address, 4.0f);
+			fvm[counter].timed_vmcall(vmcall_address, 4.0f);
 		}
 		asm("" : : : "memory");
 		auto frt2 = time_now();
@@ -574,7 +574,7 @@ void benchmark_multiple_pooled_vms(tinykvm::Machine& master_vm, size_t NUM, size
 		if constexpr (FULL_RESET) {
 			fvm->timed_vmcall(data.addr, 4.0f);
 		} else {
-			fvm->timed_reentry(data.addr, 4.0f);
+			fvm->timed_vmcall(data.addr, 4.0f);
 		}
 		asm("" : : : "memory");
 		auto frt2 = time_now();

tests/unit/reset.cpp

@@ -154,13 +154,13 @@ extern void crash(const char *arg) {
 		REQUIRE(output_is_hello_world);
 
 		output_is_hello_world = false;
-		m.timed_reentry(m.address_of("hello_world"), 2.0f, "Hello World!");
+		m.timed_vmcall(m.address_of("hello_world"), 2.0f, "Hello World!");
 		REQUIRE(m.return_value() == 1023);
 		REQUIRE(output_is_hello_world);
 
 		output_is_hello_world = false;
 		try {
-			m.timed_reentry(m.address_of("crash"), 2.0f, "Hello World!");
+			m.timed_vmcall(m.address_of("crash"), 2.0f, "Hello World!");
 		} catch (...) {}
 		REQUIRE(output_is_hello_world);