lguest: write more information to userspace about pending traps.

This is preparation for userspace handling MMIO and ioport accesses.

Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>

diff --git a/drivers/lguest/core.c b/drivers/lguest/core.c
index cdb2f9aa58605dfe7dda9246f4e28aa05749b9c3..9159dbc583f67ea9a9fbbfa169f9918cc8259742 100644 (file)
--- a/drivers/lguest/core.c
+++ b/drivers/lguest/core.c
@@ -229,16 +229,17 @@ int run_guest(struct lg_cpu *cpu, unsigned long __user *user)
                 * It's possible the Guest did a NOTIFY hypercall to the
                 * Launcher.
                 */
-               if (cpu->pending_notify) {
+               if (cpu->pending.trap) {
                        /*
                         * Does it just needs to write to a registered
                         * eventfd (ie. the appropriate virtqueue thread)?
                         */
                        if (!send_notify_to_eventfd(cpu)) {
                                /* OK, we tell the main Launcher. */
-                               if (put_user(cpu->pending_notify, user))
+                               if (copy_to_user(user, &cpu->pending,
+                                                sizeof(cpu->pending)))
                                        return -EFAULT;
-                               return sizeof(cpu->pending_notify);
+                               return sizeof(cpu->pending);
                        }
                }
 

diff --git a/drivers/lguest/hypercalls.c b/drivers/lguest/hypercalls.c
index 83511eb0923d2f908a9e884d6470d493548e5cc0..5dd1fb8a6610a4bcca299431e29e2efa148adf44 100644 (file)
--- a/drivers/lguest/hypercalls.c
+++ b/drivers/lguest/hypercalls.c
@@ -118,7 +118,8 @@ static void do_hcall(struct lg_cpu *cpu, struct hcall_args *args)
                cpu->halted = 1;
                break;
        case LHCALL_NOTIFY:
-               cpu->pending_notify = args->arg1;
+               cpu->pending.trap = LGUEST_TRAP_ENTRY;
+               cpu->pending.addr = args->arg1;
                break;
        default:
                /* It should be an architecture-specific hypercall. */
@@ -189,7 +190,7 @@ static void do_async_hcalls(struct lg_cpu *cpu)
                 * Stop doing hypercalls if they want to notify the Launcher:
                 * it needs to service this first.
                 */
-               if (cpu->pending_notify)
+               if (cpu->pending.trap)
                        break;
        }
 }
@@ -280,7 +281,7 @@ void do_hypercalls(struct lg_cpu *cpu)
         * NOTIFY to the Launcher, we want to return now.  Otherwise we do
         * the hypercall.
         */
-       if (!cpu->pending_notify) {
+       if (!cpu->pending.trap) {
                do_hcall(cpu, cpu->hcall);
                /*
                 * Tricky point: we reset the hcall pointer to mark the

diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h
index 1c98bf74fd68b611a451f6673b0f95c32601a628..020fec5bb072035b4dad81fcdcf80e1777caa0f0 100644 (file)
--- a/drivers/lguest/lg.h
+++ b/drivers/lguest/lg.h
@@ -50,7 +50,8 @@ struct lg_cpu {
        /* Bitmap of what has changed: see CHANGED_* above. */
        int changed;
 
-       unsigned long pending_notify; /* pfn from LHCALL_NOTIFY */
+       /* Pending operation. */
+       struct lguest_pending pending;
 
        unsigned long *reg_read; /* register from LHREQ_GETREG */
 

diff --git a/drivers/lguest/lguest_user.c b/drivers/lguest/lguest_user.c
index 7f14c152dd23b3ca339906fb7c6bdbafdf44f76b..dcf9efd94cf4094195d98d41a354b9cc474b2f06 100644 (file)
--- a/drivers/lguest/lguest_user.c
+++ b/drivers/lguest/lguest_user.c
@@ -29,6 +29,10 @@ bool send_notify_to_eventfd(struct lg_cpu *cpu)
        unsigned int i;
        struct lg_eventfd_map *map;
 
+       /* We only connect LHCALL_NOTIFY to event fds, not other traps. */
+       if (cpu->pending.trap != LGUEST_TRAP_ENTRY)
+               return false;
+
        /*
         * This "rcu_read_lock()" helps track when someone is still looking at
         * the (RCU-using) eventfds array.  It's not actually a lock at all;
@@ -52,9 +56,9 @@ bool send_notify_to_eventfd(struct lg_cpu *cpu)
         * we'll continue to use the old array and just won't see the new one.
         */
        for (i = 0; i < map->num; i++) {
-               if (map->map[i].addr == cpu->pending_notify) {
+               if (map->map[i].addr == cpu->pending.addr) {
                        eventfd_signal(map->map[i].event, 1);
-                       cpu->pending_notify = 0;
+                       cpu->pending.trap = 0;
                        break;
                }
        }
@@ -62,7 +66,7 @@ bool send_notify_to_eventfd(struct lg_cpu *cpu)
        rcu_read_unlock();
 
        /* If we cleared the notification, it's because we found a match. */
-       return cpu->pending_notify == 0;
+       return cpu->pending.trap == 0;
 }
 
 /*L:055
@@ -282,8 +286,8 @@ static ssize_t read(struct file *file, char __user *user, size_t size,loff_t*o)
         * If we returned from read() last time because the Guest sent I/O,
         * clear the flag.
         */
-       if (cpu->pending_notify)
-               cpu->pending_notify = 0;
+       if (cpu->pending.trap)
+               cpu->pending.trap = 0;
 
        /* Run the Guest until something interesting happens. */
        return run_guest(cpu, (unsigned long __user *)user);

diff --git a/include/linux/lguest_launcher.h b/include/linux/lguest_launcher.h
index f27cae27b0c199b1e5d6d85b13e9f69b1bd12af2..c4451ebece4713e320c5336a99df3713a556b067 100644 (file)
--- a/include/linux/lguest_launcher.h
+++ b/include/linux/lguest_launcher.h
@@ -67,6 +67,19 @@ enum lguest_req
        LHREQ_SETREG, /* + offset within struct pt_regs, value. */
 };
 
+/*
+ * This is what read() of the lguest fd populates.  trap ==
+ * LGUEST_TRAP_ENTRY for an LHCALL_NOTIFY (addr is the
+ * argument), 14 for a page fault in the MMIO region (addr is
+ * the trap address, insn is the instruction), or 13 for a GPF
+ * (insn is the instruction).
+ */
+struct lguest_pending {
+       __u8 trap;
+       __u8 insn[7];
+       __u32 addr;
+};
+
 /*
  * The alignment to use between consumer and producer parts of vring.
  * x86 pagesize for historical reasons.

diff --git a/tools/lguest/lguest.c b/tools/lguest/lguest.c
index 3f7f2326cd9a26487041eb3d2b4d16cc95d39e3a..0e754d04876d06399f6d8fd6ba38c72c9fb34d37 100644 (file)
--- a/tools/lguest/lguest.c
+++ b/tools/lguest/lguest.c
@@ -1820,17 +1820,21 @@ static void __attribute__((noreturn)) restart_guest(void)
 static void __attribute__((noreturn)) run_guest(void)
 {
        for (;;) {
-               unsigned long notify_addr;
+               struct lguest_pending notify;
                int readval;
 
                /* We read from the /dev/lguest device to run the Guest. */
-               readval = pread(lguest_fd, &notify_addr,
-                               sizeof(notify_addr), cpu_id);
+               readval = pread(lguest_fd, &notify, sizeof(notify), cpu_id);
 
                /* One unsigned long means the Guest did HCALL_NOTIFY */
-               if (readval == sizeof(notify_addr)) {
-                       verbose("Notify on address %#lx\n", notify_addr);
-                       handle_output(notify_addr);
+               if (readval == sizeof(notify)) {
+                       if (notify.trap == 0x1F) {
+                               verbose("Notify on address %#08x\n",
+                                       notify.addr);
+                               handle_output(notify.addr);
+                       } else
+                               errx(1, "Unknown trap %i addr %#08x\n",
+                                    notify.trap, notify.addr);
                /* ENOENT means the Guest died.  Reading tells us why. */
                } else if (errno == ENOENT) {
                        char reason[1024] = { 0 };