VMM: add two vthread functions.
authorRonald G. Minnich <rminnich@gmail.com>
Wed, 7 Sep 2016 16:15:53 +0000 (09:15 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 7 Sep 2016 16:37:40 +0000 (12:37 -0400)
The intent of these functions it to give users a familiar
API (pthreads).  I just had the experience of running the
naming by a non-Akaros person and the reaction was really
positive to the pthreads similarity.

Here's a usage example:

struct virtual_machine vm[1];

static volatile int count;

static void vmcall(void *a)
{
while (count < 1000000) {
__asm__ __volatile__("vmcall\n\t");
count++;
}
count++;
while (1);
}

int main(int argc, char **argv)
{

vthread_attr_init(vm, 0);
vthread_create(vm, 0, (uint64_t) vmcall, NULL);

while(count < 2) {
}

return 0;
}

Change-Id: I3e72d8a0efd89482d2f9856daccb7945f7ae1c92
Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
[minor formatting]
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/vmm/include/vmm/sched.h
user/vmm/include/vmm/vmm.h
user/vmm/vthread.c [new file with mode: 0644]

index c9a7136..403ca3f 100644 (file)
@@ -80,4 +80,8 @@ void start_guest_thread(struct guest_thread *gth);
 struct task_thread *vmm_run_task(struct virtual_machine *vm,
                                  void (*func)(void *), void *arg);
 
+int vthread_attr_init(struct virtual_machine *vm, int vmmflags);
+int vthread_attr_kernel_init(struct virtual_machine *vm, int vmmflags);
+int vthread_create(struct virtual_machine *vm, int guest, void *rip, void *arg);
+
 __END_DECLS
index 5139b2a..e5f3f35 100644 (file)
@@ -27,12 +27,19 @@ struct virtual_machine {
        struct guest_thread                     **gths;
        unsigned int                            nr_gpcs;
        struct vmm_gpcore_init          *gpcis;
+       bool                                            vminit;
 
        /* TODO: put these in appropriate structures.  e.g., virtio things in
         * something related to virtio.  low4k in something related to the guest's
         * memory. */
        uint8_t                                         *low4k;
        struct virtio_mmio_dev          *virtio_mmio_devices[VIRTIO_MMIO_MAX_NUM_DEV];
+
+       /* Default root pointer to use if one is not set in a
+        * guest thread. We expect this to be the common case,
+        * where all guests share a page table. It's not required
+        * however. */
+       void                                            *root;
 };
 
 char *regname(uint8_t reg);
diff --git a/user/vmm/vthread.c b/user/vmm/vthread.c
new file mode 100644 (file)
index 0000000..e7963e5
--- /dev/null
@@ -0,0 +1,177 @@
+/* Copyright (c) 2016 Google Inc.
+ *
+ * See LICENSE for details.
+ *
+ * Helper functions for virtual machines */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <parlib/bitmask.h>
+#include <parlib/uthread.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <vmm/vmm.h>
+
+
+static void *page(void *addr, int count)
+{
+       void *v;
+       unsigned long flags = MAP_POPULATE | MAP_ANONYMOUS;
+
+       if (addr)
+               flags |= MAP_FIXED;
+       return mmap(addr, count * 4096, PROT_READ | PROT_WRITE, flags, -1, 0);
+}
+
+/* vmsetup is a basic helper function used by vthread_attr_init
+ * and vthread_attr_kernel_init. */
+static int vmsetup(struct virtual_machine *vm, int flags)
+{
+       unsigned long long *p512, *p1;
+       struct vm_trapframe *vm_tf;
+       int i, ret;
+       uint8_t *p;
+
+       if (vm->vminit)
+               return -EBUSY;
+
+       if (vm->nr_gpcs == 0)
+               vm->nr_gpcs = 1;
+
+       vm->gpcis = calloc(vm->nr_gpcs, sizeof(*vm->gpcis));
+
+       /* Set up default page mappings. The common case,
+        * for user VM threads and kernel VM threads, is that
+        * they need some kind of initial page tables. The kernels
+        * will almost always throw them away; the user VM threads
+        * will almost always continue to use them. Using two
+        * pages and setting up an initial page table is
+        * cheap and makes users lives easier. This initial
+        * page table can grow to 512 GiB, which should be enough
+        * for now.
+        *
+        * At the same time, we allow users to select other
+        * arrangements if they wish.  Here's a simple example: is it
+        * possible someone will want a different guest page table for
+        * every guest? Yes.
+        *
+        * We lock the page table to 0x1000000 for now. We can't just
+        * let it pick anything as it may pick something the guest
+        * can't address (i.e. outside EPT range). */
+
+       /* Allocate 2 pages for page table pages: a page of
+        * 512 GiB PTEs with only one entry filled to point to
+        * a page of 1 GiB PTEs; a page of 1 GiB PTEs with
+        * only one entry filled. */
+
+       p512 = page((void *)0x1000000, 2);
+       if (!p512) {
+               werrstr("page table allocation failed: %r\n");
+               return -1;
+       }
+       p1 = &p512[512];
+       vm->root = p512;
+
+       /* Set up a 1:1 ("identity") page mapping from host
+        * virtual to guest physical for 1 GiB.  This mapping
+        * is used unless the guest (e.g. Linux) sets up its
+        * own page tables. Be aware that the values stored in
+        * the table are physical addresses.  This is subtle
+        * and mistakes are easily disguised due to the
+        * identity mapping, so take care when manipulating
+        * these mappings. Note: we don't yet have symbols for
+        * "start of virtual address common to host and guest"
+        * so we just use  the first GiB for now. */
+       p512[PML4(0x400000)] = (uint64_t)p1 | PTE_KERN_RW;
+       p1[PML3(0x400000)] = PTE_PS | PTE_KERN_RW;
+
+       /* technically, we don't need these pages for the
+        * all guests. Currently, the kernel requires them. */
+       for (i = 0; i < vm->nr_gpcs; i++) {
+               p = page(NULL, 3);
+               if (!p) {
+                       werrstr("Can't allocate 3 pages for guest %d: %r", i);
+                       return -1;
+               }
+               vm->gpcis[i].posted_irq_desc = &p[0];
+               vm->gpcis[i].vapic_addr = &p[4096];
+               vm->gpcis[i].apic_addr = &p[8192];
+       }
+
+       ret = vmm_init(vm, flags);
+       if (ret)
+               return ret;
+
+       for (i = 0; i < vm->nr_gpcs; i++) {
+               vm_tf = gth_to_vmtf(vm->gths[i]);
+               vm_tf->tf_cr3 = (uint64_t)p512;
+       }
+       vm->vminit = 1;
+
+       return 0;
+}
+
+/* vthread_addr sets up a virtual_machine struct such that functions
+ * can start up VM guests.  It is like pthread_attr in that it sets up
+ * default attributes and can be used in vthread_create calls. If
+ * vm->nrgpcs is not set then the vm will be set up for 1 guest. */
+int vthread_attr_init(struct virtual_machine *vm, int vmmflags)
+{
+       return vmsetup(vm, vmmflags);
+}
+
+/* vthread_attr_kernel_init sets up minimum basic attributes for
+ * running a kernel, as opposed to just user mode.  This setup
+ * includes an APIC page at 0xfee00000, to be shared by all cores. */
+int vthread_attr_kernel_init(struct virtual_machine *vm, int vmmflags)
+{
+       int ret;
+       int i;
+       uint32_t *apic;
+
+       ret = vmsetup(vm, vmmflags);
+       if (ret)
+               return ret;
+
+       for (i = 0; i < vm->nr_gpcs; i++) {
+               apic = vm->gpcis[i].apic_addr;
+               apic[0x30 / 4] = 0x01060015;
+       }
+       return 0;
+}
+
+#define DEFAULT_STACK_SIZE 65536
+/* vthread_create creates and starts a VM guest. The interface is intended
+ * to be as much like pthread_create as possible. */
+int vthread_create(struct virtual_machine *vm, int guest, void *rip, void *arg)
+{
+       struct vm_trapframe *vm_tf;
+       int ret;
+       uint64_t *stack, *tos;
+
+       if (!vm->vminit) {
+               return -EAGAIN;
+       }
+
+       if (guest > vm->nr_gpcs)
+               return -ENOENT;
+
+       vm_tf = gth_to_vmtf(vm->gths[guest]);
+
+       /* For now we make the default VM stack pretty small.
+        * We can grow it as needed. */
+       if (!vm_tf->tf_rsp) {
+               ret = posix_memalign((void **)&stack, 4096, DEFAULT_STACK_SIZE);
+               if (ret)
+                       return ret;
+               /* touch the top word on the stack so we don't page fault
+                * on that in the VM. */
+               tos = &stack[DEFAULT_STACK_SIZE/sizeof(uint64_t) - 1];
+               *tos = 0;
+               vm_tf->tf_rsp = (uint64_t) tos;
+       }
+       vm_tf->tf_rip = (uint64_t)rip;
+       vm_tf->tf_rdi = (uint64_t)arg;
+       start_guest_thread(vm->gths[guest]);
+       return 0;
+}