[libhv] API change: support multiple VMs in a process

nyuichi · nyuichi · commit e7449424478b · 2017-06-28T01:14:59.000+09:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -2,8 +2,6 @@ cmake_minimum_required(VERSION 2.4)
 
 project(hypervisor)
 
-set(CMAKE_BUILD_TYPE Release)
-
 include_directories(include)
 
 include(${CMAKE_SYSTEM_NAME}.cmake)
diff --git a/include/vmm.h b/include/vmm.h
@@ -9,10 +9,6 @@ extern "C" {
 #include <stdbool.h>
 #include <stddef.h>
 
-typedef const void *vmm_uvaddr_t;
-typedef uint64_t vmm_gpaddr_t;
-typedef uint64_t vmm_memory_flags_t, vmm_cpu_flags_t;
-
 #define VMM_ERROR   (-1)
 #define VMM_EBUSY   (-2)
 #define VMM_EINVAL  (-3)
@@ -85,23 +81,31 @@ enum {
   VMM_EXIT_REASONS_MAX,
 };
 
-int vmm_create(void);
-int vmm_destroy(void);
+typedef int vmm_vmid_t;
+
+int vmm_create(vmm_vmid_t *vm);
+int vmm_destroy(vmm_vmid_t vm);
 
-int vmm_memory_map(vmm_uvaddr_t uva, vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags);
-int vmm_memory_unmap(vmm_gpaddr_t gpa, size_t size);
-int vmm_memory_protect(vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags);
+int vmm_get(vmm_vmid_t vm, int id, uint64_t *value);
+int vmm_set(vmm_vmid_t vm, int id, uint64_t value);
 
-int vmm_cpu_create(void);
-int vmm_cpu_destroy(void);
-int vmm_cpu_run(void);
-int vmm_cpu_read_register(vmm_x64_reg_t reg, uint64_t *value);
-int vmm_cpu_write_register(vmm_x64_reg_t reg, uint64_t value);
-int vmm_cpu_read_msr(uint32_t msr, uint64_t *value);
-int vmm_cpu_write_msr(uint32_t msr, uint64_t value);
+typedef int vmm_cpuid_t;
+
+int vmm_cpu_create(vmm_vmid_t vm, vmm_cpuid_t *cpu);
+int vmm_cpu_destroy(vmm_vmid_t vm);
+int vmm_cpu_run(vmm_vmid_t vm);
+int vmm_cpu_get_register(vmm_vmid_t vm, vmm_cpuid_t cpu, vmm_x64_reg_t reg, uint64_t *value);
+int vmm_cpu_set_register(vmm_vmid_t vm, vmm_cpuid_t cpu, vmm_x64_reg_t reg, uint64_t value);
+int vmm_cpu_get_msr(vmm_vmid_t vm, vmm_cpuid_t cpu, uint32_t msr, uint64_t *value);
+int vmm_cpu_set_msr(vmm_vmid_t vm, vmm_cpuid_t cpu, uint32_t msr, uint64_t value);
+
+typedef const void *vmm_uvaddr_t;
+typedef uint64_t vmm_gpaddr_t;
+typedef uint64_t vmm_memory_flags_t;
 
-int vmm_get(int id, uint64_t *value);
-int vmm_set(int id, uint64_t value);
+int vmm_memory_map(vmm_vmid_t vm, vmm_uvaddr_t uva, vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags);
+int vmm_memory_unmap(vmm_vmid_t vm, vmm_gpaddr_t gpa, size_t size);
+int vmm_memory_protect(vmm_vmid_t vm, vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags);
 
 #ifdef __cplusplus
 }
diff --git a/src/vmm_kvm.c b/src/vmm_kvm.c
@@ -12,84 +12,90 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 
-static int kvm, vmfd;
-static struct kvm_run *run;
-static struct kvm_regs regs;
-static struct kvm_sregs sregs;
-static int vcpufd;
+static int kvm = -1;
+static __thread int vcpufd = -1;
+static __thread struct kvm_run *run;
+static int mmap_size = -1;
 
 int
-vmm_create(void)
+vmm_create(vmm_vmid_t *vm)
 {
   int ret;
 
-  if ((kvm = open("/dev/kvm", O_RDWR | O_CLOEXEC)) < 0)
-    return VMM_ENOTSUP;
+  if (kvm < 0) {
+    if ((kvm = open("/dev/kvm", O_RDWR | O_CLOEXEC)) < 0) {
+      return VMM_ENOTSUP;
+    }
+  }
 
   /* check API version */
   if ((ret = ioctl(kvm, KVM_GET_API_VERSION, NULL)) < 0)
     return VMM_ERROR;
   if (ret != 12)
     return VMM_ENOTSUP;
 
-  if ((vmfd = ioctl(kvm, KVM_CREATE_VM, 0UL)) < 0)
+  if ((*vm = ioctl(kvm, KVM_CREATE_VM, 0UL)) < 0)
     return VMM_ERROR;
 
   return 0;
 }
 
 int
-vmm_destroy(void)
+vmm_destroy(vmm_vmid_t vm)
 {
-  close(vmfd);
-  close(kvm);
+  close(vm);
   return 0;
 }
 
 int
-vmm_memory_map(vmm_uvaddr_t uva, vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags)
+vmm_memory_map(vmm_vmid_t vm, vmm_uvaddr_t uva, vmm_gpaddr_t gpa, size_t size, vmm_memory_flags_t flags)
 {
   struct kvm_userspace_memory_region region = {
     .slot = 0,
+    .flags = 0,
     .guest_phys_addr = gpa,
     .memory_size = size,
     .userspace_addr = (uint64_t)uva,
   };
   int ret;
 
-  if ((ret = ioctl(vmfd, KVM_SET_USER_MEMORY_REGION, &region)) < 0)
+  if ((ret = ioctl(vm, KVM_SET_USER_MEMORY_REGION, &region)) < 0)
     return VMM_ERROR;
 
   return 0;
 }
 
 int
-vmm_cpu_create(void)
+vmm_cpu_create(vmm_vmid_t vm, vmm_cpuid_t *cpu)
 {
-  int mmap_size;
-
-  if ((vcpufd = ioctl(vmfd, KVM_CREATE_VCPU, 0UL)) < 0)
+  if ((vcpufd = ioctl(vm, KVM_CREATE_VCPU, 0UL)) < 0)
     return VMM_ERROR;
 
+  *cpu = vcpufd;
+
   /* Map the shared kvm_run structure and following data. */
-  if ((mmap_size = ioctl(kvm, KVM_GET_VCPU_MMAP_SIZE, NULL)) < 0)
-    return VMM_ERROR;
-  if ((run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpufd, 0)) == 0)
+  if (mmap_size < 0) {
+    if ((mmap_size = ioctl(kvm, KVM_GET_VCPU_MMAP_SIZE, NULL)) < 0)
+      return VMM_ERROR;
+  }
+  if ((run = mmap(NULL, mmap_size, PROT_READ | PROT_WRITE, MAP_SHARED, vcpufd, 0)) == MAP_FAILED)
     return VMM_ERROR;
-
+  assert(run != 0);
   return 0;
 }
 
 int
-vmm_cpu_destroy(void)
+vmm_cpu_destroy(vmm_vmid_t vm)
 {
-  close(vcpufd);
+  if (munmap(run, mmap_size) < 0)
+    return -VMM_ERROR;
   run = NULL;
+  close(vcpufd);
   return 0;
 }
 
 int
-vmm_cpu_run(void)
+vmm_cpu_run(vmm_vmid_t vm)
 {
   if (ioctl(vcpufd, KVM_RUN, NULL) < 0)
     return VMM_ERROR;
@@ -135,11 +141,14 @@ struct kvm_sregs {
 */
 
 int
-vmm_cpu_write_register(vmm_x64_reg_t reg, uint64_t value)
+vmm_cpu_set_register(vmm_vmid_t vm, vmm_cpuid_t cpu, vmm_x64_reg_t reg, uint64_t value)
 {
-  if (ioctl(vcpufd, KVM_GET_REGS, &regs) < 0)
+  static struct kvm_regs regs;
+  static struct kvm_sregs sregs;
+
+  if (ioctl(cpu, KVM_GET_REGS, &regs) < 0)
     return VMM_ERROR;
-  if (ioctl(vcpufd, KVM_GET_SREGS, &sregs) < 0)
+  if (ioctl(cpu, KVM_GET_SREGS, &sregs) < 0)
     return VMM_ERROR;
 
   switch (reg) {
@@ -199,20 +208,23 @@ vmm_cpu_write_register(vmm_x64_reg_t reg, uint64_t value)
     assert(false);
   }
 
-  if (ioctl(vcpufd, KVM_SET_REGS, &regs) < 0)
+  if (ioctl(cpu, KVM_SET_REGS, &regs) < 0)
     return VMM_ERROR;
-  if (ioctl(vcpufd, KVM_SET_SREGS, &sregs) < 0)
+  if (ioctl(cpu, KVM_SET_SREGS, &sregs) < 0)
     return VMM_ERROR;
 
   return 0;
 }
 
 int
-vmm_cpu_read_register(vmm_x64_reg_t reg, uint64_t *value)
+vmm_cpu_get_register(vmm_vmid_t vm, vmm_cpuid_t cpu, vmm_x64_reg_t reg, uint64_t *value)
 {
-  if (ioctl(vcpufd, KVM_GET_REGS, &regs) < 0)
+  static struct kvm_regs regs;
+  static struct kvm_sregs sregs;
+
+  if (ioctl(cpu, KVM_GET_REGS, &regs) < 0)
     return VMM_ERROR;
-  if (ioctl(vcpufd, KVM_GET_SREGS, &sregs) < 0)
+  if (ioctl(cpu, KVM_GET_SREGS, &sregs) < 0)
     return VMM_ERROR;
 
   switch (reg) {
@@ -274,7 +286,7 @@ vmm_cpu_read_register(vmm_x64_reg_t reg, uint64_t *value)
 }
 
 int
-vmm_get(int id, uint64_t *value)
+vmm_get(vmm_vmid_t vm, int id, uint64_t *value)
 {
   assert(id == VMM_CTRL_EXIT_REASON);
 
diff --git a/test/main.c b/test/main.c
@@ -28,6 +28,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <assert.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 
@@ -43,8 +44,11 @@ int main(void)
     0xf4,             /* hlt */
   };
   uint8_t *mem;
+  int ret;
 
-  vmm_create();
+  vmm_vmid_t vm;
+  ret = vmm_create(&vm);
+  assert(ret == 0);
 
   /* Allocate one aligned page of guest memory to hold the code. */
   mem = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
@@ -55,26 +59,31 @@ int main(void)
   memcpy(mem, code, sizeof(code));
 
   /* Map it to the second page frame (to avoid the real-mode IDT at 0). */
-  vmm_memory_map(mem, 0x1000, 0x1000, 0);
+  ret = vmm_memory_map(vm, mem, 0x1000, 0x1000, 0);
+  assert(ret == 0);
 
-  vmm_cpu_create();
+  vmm_cpuid_t cpu;
+  ret = vmm_cpu_create(vm, &cpu);
+  assert(ret == 0);
 
   /*
    * Initialize CS to point at 0, via a read-modify-write of sregs.
    * Initialize registers: instruction pointer for our code, addends, and
    * initial flags required by x86 architecture.
    */
-  vmm_cpu_write_register(VMM_X64_CS, 0);
-  vmm_cpu_write_register(VMM_X64_RIP, 0x1000);
-  vmm_cpu_write_register(VMM_X64_RAX, 2);
-  vmm_cpu_write_register(VMM_X64_RBX, 2);
-  vmm_cpu_write_register(VMM_X64_RFLAGS, 0x2);
+  vmm_cpu_set_register(vm, cpu, VMM_X64_CS, 0);
+  vmm_cpu_set_register(vm, cpu, VMM_X64_RIP, 0x1000);
+  vmm_cpu_set_register(vm, cpu, VMM_X64_RAX, 2);
+  vmm_cpu_set_register(vm, cpu, VMM_X64_RBX, 2);
+  vmm_cpu_set_register(vm, cpu, VMM_X64_RFLAGS, 0x2);
 
   /* Repeatedly run code and handle VM exits. */
   while (1) {
-    vmm_cpu_run();
+    ret = vmm_cpu_run(vm);
+    assert(ret == 0);
     uint64_t exit_reason, value;
-    vmm_get(VMM_CTRL_EXIT_REASON, &exit_reason);
+    ret = vmm_get(vm, VMM_CTRL_EXIT_REASON, &exit_reason);
+    assert(ret == 0);
     switch (exit_reason) {
     case VMM_EXIT_HLT:
       puts("KVM_EXIT_HLT");
@@ -85,7 +94,8 @@ int main(void)
       //else
       //  errx(1, "unhandled KVM_EXIT_IO");
       //break;
-      vmm_cpu_read_register(VMM_X64_RAX, &value);
+      ret = vmm_cpu_get_register(vm, cpu, VMM_X64_RAX, &value);
+      assert(ret == 0);
       putchar((char) value);
       break;
     /* case KVM_EXIT_FAIL_ENTRY: */
@@ -94,7 +104,8 @@ int main(void)
     /* case KVM_EXIT_INTERNAL_ERROR: */
     /*   errx(1, "KVM_EXIT_INTERNAL_ERROR: suberror = 0x%x", run->internal.suberror); */
     default:
-     vmm_cpu_read_register(VMM_X64_RIP, &value);
+     ret = vmm_cpu_get_register(vm, cpu, VMM_X64_RIP, &value);
+     assert(ret == 0);
      fprintf(stderr, "ip = 0x%lx\n", value);
      fprintf(stderr, "exit_reason = 0x%lx", exit_reason);
      abort();
