4 files changed, 94 insertions, 75 deletions

diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index eb8a78d77d9d..533a199e7a3f 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -8,9 +8,12 @@ obj-$(CONFIG_BLOCK)		+= biomerge.o
 obj-$(CONFIG_HOTPLUG_CPU)       += cpu_hotplug.o
 obj-$(CONFIG_XEN_XENCOMM)       += xencomm.o
 obj-$(CONFIG_XEN_BALLOON)       += balloon.o
-obj-$(CONFIG_XEN_DEV_EVTCHN)    += evtchn.o
+obj-$(CONFIG_XEN_DEV_EVTCHN)    += xen-evtchn.o
 obj-$(CONFIG_XENFS)             += xenfs/
 obj-$(CONFIG_XEN_SYS_HYPERVISOR)        += sys-hypervisor.o
 obj-$(CONFIG_XEN_PLATFORM_PCI)  += platform-pci.o
 obj-$(CONFIG_SWIOTLB_XEN)       += swiotlb-xen.o
 obj-$(CONFIG_XEN_DOM0)          += pci.o
+
+xen-evtchn-y                    := evtchn.o
+
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index fec6ba3c08a8..ef11daf0cafe 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -69,20 +69,51 @@ struct per_user_data {
         const char *name;
 };
 
-/* Who's bound to each port? */
-static struct per_user_data *port_user[NR_EVENT_CHANNELS];
+/*
+ * Who's bound to each port?  This is logically an array of struct
+ * per_user_data *, but we encode the current enabled-state in bit 0.
+ */
+static unsigned long *port_user;
 static DEFINE_SPINLOCK(port_user_lock); /* protects port_user[] and ring_prod */
 
-irqreturn_t evtchn_interrupt(int irq, void *data)
+static inline struct per_user_data *get_port_user(unsigned port)
+{
+        return (struct per_user_data *)(port_user[port] & ~1);
+}
+
+static inline void set_port_user(unsigned port, struct per_user_data *u)
+{
+        port_user[port] = (unsigned long)u;
+}
+
+static inline bool get_port_enabled(unsigned port)
+{
+        return port_user[port] & 1;
+}
+
+static inline void set_port_enabled(unsigned port, bool enabled)
+{
+        if (enabled)
+                port_user[port] |= 1;
+        else
+                port_user[port] &= ~1;
+}
+
+static irqreturn_t evtchn_interrupt(int irq, void *data)
 {
         unsigned int port = (unsigned long)data;
         struct per_user_data *u;
 
         spin_lock(&port_user_lock);
 
-        u = port_user[port];
+        u = get_port_user(port);
+
+        WARN(!get_port_enabled(port),
+             "Interrupt for port %d, but apparently not enabled; per-user %p\n",
+             port, u);
 
         disable_irq_nosync(irq);
+        set_port_enabled(port, false);
 
         if ((u->ring_prod - u->ring_cons) < EVTCHN_RING_SIZE) {
                 u->ring[EVTCHN_RING_MASK(u->ring_prod)] = port;
@@ -92,9 +123,8 @@ irqreturn_t evtchn_interrupt(int irq, void *data)
                         kill_fasync(&u->evtchn_async_queue,
                                     SIGIO, POLL_IN);
                 }
-        } else {
+        } else
                 u->ring_overflow = 1;
-        }
 
         spin_unlock(&port_user_lock);
 
@@ -198,9 +228,18 @@ static ssize_t evtchn_write(struct file *file, const char __user *buf,
                 goto out;
 
         spin_lock_irq(&port_user_lock);
-        for (i = 0; i < (count/sizeof(evtchn_port_t)); i++)
-                if ((kbuf[i] < NR_EVENT_CHANNELS) && (port_user[kbuf[i]] == u))
-                        enable_irq(irq_from_evtchn(kbuf[i]));
+
+        for (i = 0; i < (count/sizeof(evtchn_port_t)); i++) {
+                unsigned port = kbuf[i];
+
+                if (port < NR_EVENT_CHANNELS &&
+                    get_port_user(port) == u &&
+                    !get_port_enabled(port)) {
+                        set_port_enabled(port, true);
+                        enable_irq(irq_from_evtchn(port));
+                }
+        }
+
         spin_unlock_irq(&port_user_lock);
 
         rc = count;
@@ -222,8 +261,9 @@ static int evtchn_bind_to_user(struct per_user_data *u, int port)
          * interrupt handler yet, and our caller has already
          * serialized bind operations.)
          */
-        BUG_ON(port_user[port] != NULL);
-        port_user[port] = u;
+        BUG_ON(get_port_user(port) != NULL);
+        set_port_user(port, u);
+        set_port_enabled(port, true); /* start enabled */
 
         rc = bind_evtchn_to_irqhandler(port, evtchn_interrupt, IRQF_DISABLED,
                                        u->name, (void *)(unsigned long)port);
@@ -239,10 +279,7 @@ static void evtchn_unbind_from_user(struct per_user_data *u, int port)
 
         unbind_from_irqhandler(irq, (void *)(unsigned long)port);
 
-        /* make sure we unbind the irq handler before clearing the port */
-        barrier();
-
-        port_user[port] = NULL;
+        set_port_user(port, NULL);
 }
 
 static long evtchn_ioctl(struct file *file,
@@ -333,15 +370,17 @@ static long evtchn_ioctl(struct file *file,
                 spin_lock_irq(&port_user_lock);
 
                 rc = -ENOTCONN;
-                if (port_user[unbind.port] != u) {
+                if (get_port_user(unbind.port) != u) {
                         spin_unlock_irq(&port_user_lock);
                         break;
                 }
 
-                evtchn_unbind_from_user(u, unbind.port);
+                disable_irq(irq_from_evtchn(unbind.port));
 
                 spin_unlock_irq(&port_user_lock);
 
+                evtchn_unbind_from_user(u, unbind.port);
+
                 rc = 0;
                 break;
         }
@@ -355,7 +394,7 @@ static long evtchn_ioctl(struct file *file,
 
                 if (notify.port >= NR_EVENT_CHANNELS) {
                         rc = -EINVAL;
-                } else if (port_user[notify.port] != u) {
+                } else if (get_port_user(notify.port) != u) {
                         rc = -ENOTCONN;
                 } else {
                         notify_remote_via_evtchn(notify.port);
@@ -431,7 +470,7 @@ static int evtchn_open(struct inode *inode, struct file *filp)
 
         filp->private_data = u;
 
-        return 0;
+        return nonseekable_open(inode, filp);;
 }
 
 static int evtchn_release(struct inode *inode, struct file *filp)
@@ -444,14 +483,21 @@ static int evtchn_release(struct inode *inode, struct file *filp)
         free_page((unsigned long)u->ring);
 
         for (i = 0; i < NR_EVENT_CHANNELS; i++) {
-                if (port_user[i] != u)
+                if (get_port_user(i) != u)
                         continue;
 
-                evtchn_unbind_from_user(port_user[i], i);
+                disable_irq(irq_from_evtchn(i));
         }
 
         spin_unlock_irq(&port_user_lock);
 
+        for (i = 0; i < NR_EVENT_CHANNELS; i++) {
+                if (get_port_user(i) != u)
+                        continue;
+
+                evtchn_unbind_from_user(get_port_user(i), i);
+        }
+
         kfree(u->name);
         kfree(u);
 
@@ -467,12 +513,12 @@ static const struct file_operations evtchn_fops = {
         .fasync  = evtchn_fasync,
         .open    = evtchn_open,
         .release = evtchn_release,
-        .llseek = noop_llseek,
+        .llseek  = no_llseek,
 };
 
 static struct miscdevice evtchn_miscdev = {
         .minor        = MISC_DYNAMIC_MINOR,
-        .name         = "evtchn",
+        .name         = "xen/evtchn",
         .fops         = &evtchn_fops,
 };
 static int __init evtchn_init(void)
@@ -482,8 +528,11 @@ static int __init evtchn_init(void)
         if (!xen_domain())
                 return -ENODEV;
 
+        port_user = kcalloc(NR_EVENT_CHANNELS, sizeof(*port_user), GFP_KERNEL);
+        if (port_user == NULL)
+                return -ENOMEM;
+
         spin_lock_init(&port_user_lock);
-        memset(port_user, 0, sizeof(port_user));
 
         /* Create '/dev/misc/evtchn'. */
         err = misc_register(&evtchn_miscdev);
@@ -499,6 +548,9 @@ static int __init evtchn_init(void)
 
 static void __exit evtchn_cleanup(void)
 {
+        kfree(port_user);
+        port_user = NULL;
+
         misc_deregister(&evtchn_miscdev);
 }
 
diff --git a/drivers/xen/xenfs/privcmd.c b/drivers/xen/xenfs/privcmd.c
index f80be7f6eb95..dbd3b16fd131 100644
--- a/drivers/xen/xenfs/privcmd.c
+++ b/drivers/xen/xenfs/privcmd.c
@@ -15,7 +15,6 @@
 #include <linux/mman.h>
 #include <linux/uaccess.h>
 #include <linux/swap.h>
-#include <linux/smp_lock.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
 #include <linux/seq_file.h>
@@ -266,9 +265,7 @@ static int mmap_return_errors(void *data, void *state)
         xen_pfn_t *mfnp = data;
         struct mmap_batch_state *st = state;
 
-        put_user(*mfnp, st->user++);
-
-        return 0;
+        return put_user(*mfnp, st->user++);
 }
 
 static struct vm_operations_struct privcmd_vm_ops;
@@ -323,10 +320,8 @@ static long privcmd_ioctl_mmap_batch(void __user *udata)
         up_write(&mm->mmap_sem);
 
         if (state.err > 0) {
-                ret = 0;
-
                 state.user = m.arr;
-                traverse_pages(m.num, sizeof(xen_pfn_t),
+                ret = traverse_pages(m.num, sizeof(xen_pfn_t),
                                &pagelist,
                                mmap_return_errors, &state);
         }
@@ -384,8 +379,9 @@ static int privcmd_mmap(struct file *file, struct vm_area_struct *vma)
         if (xen_feature(XENFEAT_auto_translated_physmap))
                 return -ENOSYS;
 
-        /* DONTCOPY is essential for Xen as copy_page_range is broken. */
-        vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY;
+        /* DONTCOPY is essential for Xen because copy_page_range doesn't know
+         * how to recreate these mappings */
+        vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY | VM_PFNMAP;
         vma->vm_ops = &privcmd_vm_ops;
         vma->vm_private_data = NULL;
 
diff --git a/drivers/xen/xenfs/super.c b/drivers/xen/xenfs/super.c
index d6662b789b6b..1aa389719846 100644
--- a/drivers/xen/xenfs/super.c
+++ b/drivers/xen/xenfs/super.c
@@ -12,8 +12,6 @@
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/magic.h>
-#include <linux/mm.h>
-#include <linux/backing-dev.h>
 
 #include <xen/xen.h>
 
@@ -24,28 +22,12 @@
 MODULE_DESCRIPTION("Xen filesystem");
 MODULE_LICENSE("GPL");
 
-static int xenfs_set_page_dirty(struct page *page)
-{
-        return !TestSetPageDirty(page);
-}
-
-static const struct address_space_operations xenfs_aops = {
-        .set_page_dirty = xenfs_set_page_dirty,
-};
-
-static struct backing_dev_info xenfs_backing_dev_info = {
-        .ra_pages       = 0,    /* No readahead */
-        .capabilities   = BDI_CAP_NO_ACCT_AND_WRITEBACK,
-};
-
 static struct inode *xenfs_make_inode(struct super_block *sb, int mode)
 {
         struct inode *ret = new_inode(sb);
 
         if (ret) {
                 ret->i_mode = mode;
-                ret->i_mapping->a_ops = &xenfs_aops;
-                ret->i_mapping->backing_dev_info = &xenfs_backing_dev_info;
                 ret->i_uid = ret->i_gid = 0;
                 ret->i_blocks = 0;
                 ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
@@ -121,41 +103,27 @@ static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
         return rc;
 }
 
-static int xenfs_get_sb(struct file_system_type *fs_type,
-                        int flags, const char *dev_name,
-                        void *data, struct vfsmount *mnt)
+static struct dentry *xenfs_mount(struct file_system_type *fs_type,
+                                  int flags, const char *dev_name,
+                                  void *data)
 {
-        return get_sb_single(fs_type, flags, data, xenfs_fill_super, mnt);
+        return mount_single(fs_type, flags, data, xenfs_fill_super);
 }
 
 static struct file_system_type xenfs_type = {
         .owner =        THIS_MODULE,
         .name =         "xenfs",
-        .get_sb =       xenfs_get_sb,
+        .mount =        xenfs_mount,
         .kill_sb =      kill_litter_super,
 };
 
 static int __init xenfs_init(void)
 {
-        int err;
-        if (!xen_domain()) {
-                printk(KERN_INFO "xenfs: not registering filesystem on non-xen platform\n");
-                return 0;
-        }
-
-        err = register_filesystem(&xenfs_type);
-        if (err) {
-                printk(KERN_ERR "xenfs: Unable to register filesystem!\n");
-                goto out;
-        }
-
-        err = bdi_init(&xenfs_backing_dev_info);
-        if (err)
-                unregister_filesystem(&xenfs_type);
-
- out:
+        if (xen_domain())
+                return register_filesystem(&xenfs_type);
 
-        return err;
+        printk(KERN_INFO "XENFS: not registering filesystem on non-xen platform\n");
+        return 0;
 }
 
 static void __exit xenfs_exit(void)