lguest: do not statically allocate root device
[linux-3.10.git] / drivers / lguest / core.c
index 35d19ae..90663e0 100644 (file)
@@ -1,8 +1,6 @@
 /*P:400 This contains run_guest() which actually calls into the Host<->Guest
  * Switcher and analyzes the return, such as determining if the Guest wants the
- * Host to do something.  This file also contains useful helper routines, and a
- * couple of non-obvious setup and teardown pieces which were implemented after
- * days of debugging pain. :*/
+ * Host to do something.  This file also contains useful helper routines. :*/
 #include <linux/module.h>
 #include <linux/stringify.h>
 #include <linux/stddef.h>
@@ -49,8 +47,8 @@ static __init int map_switcher(void)
         * easy.
         */
 
-       /* We allocate an array of "struct page"s.  map_vm_area() wants the
-        * pages in this form, rather than just an array of pointers. */
+       /* We allocate an array of struct page pointers.  map_vm_area() wants
+        * this, rather than just an array of pages. */
        switcher_page = kmalloc(sizeof(switcher_page[0])*TOTAL_SWITCHER_PAGES,
                                GFP_KERNEL);
        if (!switcher_page) {
@@ -69,11 +67,22 @@ static __init int map_switcher(void)
                switcher_page[i] = virt_to_page(addr);
        }
 
+       /* First we check that the Switcher won't overlap the fixmap area at
+        * the top of memory.  It's currently nowhere near, but it could have
+        * very strange effects if it ever happened. */
+       if (SWITCHER_ADDR + (TOTAL_SWITCHER_PAGES+1)*PAGE_SIZE > FIXADDR_START){
+               err = -ENOMEM;
+               printk("lguest: mapping switcher would thwack fixmap\n");
+               goto free_pages;
+       }
+
        /* Now we reserve the "virtual memory area" we want: 0xFFC00000
         * (SWITCHER_ADDR).  We might not get it in theory, but in practice
-        * it's worked so far. */
+        * it's worked so far.  The end address needs +1 because __get_vm_area
+        * allocates an extra guard page, so we need space for that. */
        switcher_vma = __get_vm_area(TOTAL_SWITCHER_PAGES * PAGE_SIZE,
-                                      VM_ALLOC, SWITCHER_ADDR, VMALLOC_END);
+                                    VM_ALLOC, SWITCHER_ADDR, SWITCHER_ADDR
+                                    + (TOTAL_SWITCHER_PAGES+1) * PAGE_SIZE);
        if (!switcher_vma) {
                err = -ENOMEM;
                printk("lguest: could not map switcher pages high\n");
@@ -126,11 +135,15 @@ static void unmap_switcher(void)
        /* Now we just need to free the pages we copied the switcher into */
        for (i = 0; i < TOTAL_SWITCHER_PAGES; i++)
                __free_pages(switcher_page[i], 0);
+       kfree(switcher_page);
 }
 
-/*L:305
+/*H:032
  * Dealing With Guest Memory.
  *
+ * Before we go too much further into the Host, we need to grok the routines
+ * we use to deal with Guest memory.
+ *
  * When the Guest gives us (what it thinks is) a physical address, we can use
  * the normal copy_from_user() & copy_to_user() on the corresponding place in
  * the memory region allocated by the Launcher.
@@ -148,43 +161,43 @@ int lguest_address_ok(const struct lguest *lg,
 /* This routine copies memory from the Guest.  Here we can see how useful the
  * kill_lguest() routine we met in the Launcher can be: we return a random
  * value (all zeroes) instead of needing to return an error. */
-void __lgread(struct lguest *lg, void *b, unsigned long addr, unsigned bytes)
+void __lgread(struct lg_cpu *cpu, void *b, unsigned long addr, unsigned bytes)
 {
-       if (!lguest_address_ok(lg, addr, bytes)
-           || copy_from_user(b, lg->mem_base + addr, bytes) != 0) {
+       if (!lguest_address_ok(cpu->lg, addr, bytes)
+           || copy_from_user(b, cpu->lg->mem_base + addr, bytes) != 0) {
                /* copy_from_user should do this, but as we rely on it... */
                memset(b, 0, bytes);
-               kill_guest(lg, "bad read address %#lx len %u", addr, bytes);
+               kill_guest(cpu, "bad read address %#lx len %u", addr, bytes);
        }
 }
 
-/* This is the write (copy into guest) version. */
-void __lgwrite(struct lguest *lg, unsigned long addr, const void *b,
+/* This is the write (copy into Guest) version. */
+void __lgwrite(struct lg_cpu *cpu, unsigned long addr, const void *b,
               unsigned bytes)
 {
-       if (!lguest_address_ok(lg, addr, bytes)
-           || copy_to_user(lg->mem_base + addr, b, bytes) != 0)
-               kill_guest(lg, "bad write address %#lx len %u", addr, bytes);
+       if (!lguest_address_ok(cpu->lg, addr, bytes)
+           || copy_to_user(cpu->lg->mem_base + addr, b, bytes) != 0)
+               kill_guest(cpu, "bad write address %#lx len %u", addr, bytes);
 }
 /*:*/
 
 /*H:030 Let's jump straight to the the main loop which runs the Guest.
  * Remember, this is called by the Launcher reading /dev/lguest, and we keep
  * going around and around until something interesting happens. */
-int run_guest(struct lguest *lg, unsigned long __user *user)
+int run_guest(struct lg_cpu *cpu, unsigned long __user *user)
 {
        /* We stop running once the Guest is dead. */
-       while (!lg->dead) {
+       while (!cpu->lg->dead) {
                /* First we run any hypercalls the Guest wants done. */
-               if (lg->hcall)
-                       do_hypercalls(lg);
+               if (cpu->hcall)
+                       do_hypercalls(cpu);
 
                /* It's possible the Guest did a NOTIFY hypercall to the
                 * Launcher, in which case we return from the read() now. */
-               if (lg->pending_notify) {
-                       if (put_user(lg->pending_notify, user))
+               if (cpu->pending_notify) {
+                       if (put_user(cpu->pending_notify, user))
                                return -EFAULT;
-                       return sizeof(lg->pending_notify);
+                       return sizeof(cpu->pending_notify);
                }
 
                /* Check for signals */
@@ -192,13 +205,13 @@ int run_guest(struct lguest *lg, unsigned long __user *user)
                        return -ERESTARTSYS;
 
                /* If Waker set break_out, return to Launcher. */
-               if (lg->break_out)
+               if (cpu->break_out)
                        return -EAGAIN;
 
-               /* Check if there are any interrupts which can be delivered
-                * now: if so, this sets up the hander to be executed when we
-                * next run the Guest. */
-               maybe_do_interrupt(lg);
+               /* Check if there are any interrupts which can be delivered now:
+                * if so, this sets up the hander to be executed when we next
+                * run the Guest. */
+               maybe_do_interrupt(cpu);
 
                /* All long-lived kernel loops need to check with this horrible
                 * thing called the freezer.  If the Host is trying to suspend,
@@ -207,12 +220,12 @@ int run_guest(struct lguest *lg, unsigned long __user *user)
 
                /* Just make absolutely sure the Guest is still alive.  One of
                 * those hypercalls could have been fatal, for example. */
-               if (lg->dead)
+               if (cpu->lg->dead)
                        break;
 
                /* If the Guest asked to be stopped, we sleep.  The Guest's
                 * clock timer or LHCALL_BREAK from the Waker will wake us. */
-               if (lg->halted) {
+               if (cpu->halted) {
                        set_current_state(TASK_INTERRUPTIBLE);
                        schedule();
                        continue;
@@ -223,15 +236,19 @@ int run_guest(struct lguest *lg, unsigned long __user *user)
                local_irq_disable();
 
                /* Actually run the Guest until something happens. */
-               lguest_arch_run_guest(lg);
+               lguest_arch_run_guest(cpu);
 
                /* Now we're ready to be interrupted or moved to other CPUs */
                local_irq_enable();
 
                /* Now we deal with whatever happened to the Guest. */
-               lguest_arch_handle_trap(lg);
+               lguest_arch_handle_trap(cpu);
        }
 
+       /* Special case: Guest is 'dead' but wants a reboot. */
+       if (cpu->lg->dead == ERR_PTR(-ERESTART))
+               return -ERESTART;
+
        /* The Guest is dead => "No such file or directory" */
        return -ENOENT;
 }
@@ -250,7 +267,7 @@ static int __init init(void)
 
        /* Lguest can't run under Xen, VMI or itself.  It does Tricky Stuff. */
        if (paravirt_enabled()) {
-               printk("lguest is afraid of %s\n", pv_info.name);
+               printk("lguest is afraid of being a guest\n");
                return -EPERM;
        }