Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus

* git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus: (27 commits)
  lguest: use __PAGE_KERNEL instead of _PAGE_KERNEL
  lguest: Use explicit includes rateher than indirect
  lguest: get rid of lg variable assignments
  lguest: change gpte_addr header
  lguest: move changed bitmap to lg_cpu
  lguest: move last_pages to lg_cpu
  lguest: change last_guest to last_cpu
  lguest: change spte_addr header
  lguest: per-vcpu lguest pgdir management
  lguest: make pending notifications per-vcpu
  lguest: makes special fields be per-vcpu
  lguest: per-vcpu lguest task management
  lguest: replace lguest_arch with lg_cpu_arch.
  lguest: make registers per-vcpu
  lguest: make emulate_insn receive a vcpu struct.
  lguest: map_switcher_in_guest() per-vcpu
  lguest: per-vcpu interrupt processing.
  lguest: per-vcpu lguest timers
  lguest: make hypercalls use the vcpu struct
  lguest: make write() operation smp aware
  ...

Manual conflict resolved (maybe even correctly, who knows) in
drivers/lguest/x86/core.c

1 files changed, 24 insertions, 22 deletions

diff --git a/drivers/lguest/core.c b/drivers/lguest/core.c
index cb4c67025d52..7743d73768df 100644
--- a/drivers/lguest/core.c
+++ b/drivers/lguest/core.c
@@ -151,43 +151,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,
+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 */
@@ -195,13 +195,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);
+                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,
@@ -210,12 +210,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;
@@ -226,15 +226,17 @@ 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);
         }
 
+        if (cpu->lg->dead == ERR_PTR(-ERESTART))
+                return -ERESTART;
         /* The Guest is dead => "No such file or directory" */
         return -ENOENT;
 }
@@ -253,7 +255,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;
         }