9 files changed, 642 insertions, 39 deletions

diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 93e98ffe71ae..97612f548a8e 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -296,7 +296,7 @@ static void init_evtchn_cpu_bindings(void)
         }
 #endif
 
-        memset(cpu_evtchn_mask(0), ~0, sizeof(cpu_evtchn_mask(0)));
+        memset(cpu_evtchn_mask(0), ~0, sizeof(struct cpu_evtchn_s));
 }
 
 static inline void clear_evtchn(int port)
@@ -791,7 +791,7 @@ int bind_evtchn_to_irq(unsigned int evtchn)
                 irq = find_unbound_irq();
 
                 set_irq_chip_and_handler_name(irq, &xen_dynamic_chip,
-                                              handle_edge_irq, "event");
+                                              handle_fasteoi_irq, "event");
 
                 evtchn_to_irq[evtchn] = irq;
                 irq_info[irq] = mk_evtchn_info(evtchn);
@@ -849,6 +849,11 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
         irq = per_cpu(virq_to_irq, cpu)[virq];
 
         if (irq == -1) {
+                irq = find_unbound_irq();
+
+                set_irq_chip_and_handler_name(irq, &xen_percpu_chip,
+                                              handle_percpu_irq, "virq");
+
                 bind_virq.virq = virq;
                 bind_virq.vcpu = cpu;
                 if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
@@ -856,11 +861,6 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
                         BUG();
                 evtchn = bind_virq.port;
 
-                irq = find_unbound_irq();
-
-                set_irq_chip_and_handler_name(irq, &xen_percpu_chip,
-                                              handle_percpu_irq, "virq");
-
                 evtchn_to_irq[evtchn] = irq;
                 irq_info[irq] = mk_virq_info(evtchn, virq);
 
@@ -992,41 +992,75 @@ irqreturn_t xen_debug_interrupt(int irq, void *dev_id)
 {
         struct shared_info *sh = HYPERVISOR_shared_info;
         int cpu = smp_processor_id();
+        unsigned long *cpu_evtchn = cpu_evtchn_mask(cpu);
         int i;
         unsigned long flags;
         static DEFINE_SPINLOCK(debug_lock);
+        struct vcpu_info *v;
 
         spin_lock_irqsave(&debug_lock, flags);
 
-        printk("vcpu %d\n  ", cpu);
+        printk("\nvcpu %d\n  ", cpu);
 
         for_each_online_cpu(i) {
-                struct vcpu_info *v = per_cpu(xen_vcpu, i);
-                printk("%d: masked=%d pending=%d event_sel %08lx\n  ", i,
-                        (get_irq_regs() && i == cpu) ? xen_irqs_disabled(get_irq_regs()) : v->evtchn_upcall_mask,
-                        v->evtchn_upcall_pending,
-                        v->evtchn_pending_sel);
+                int pending;
+                v = per_cpu(xen_vcpu, i);
+                pending = (get_irq_regs() && i == cpu)
+                        ? xen_irqs_disabled(get_irq_regs())
+                        : v->evtchn_upcall_mask;
+                printk("%d: masked=%d pending=%d event_sel %0*lx\n  ", i,
+                       pending, v->evtchn_upcall_pending,
+                       (int)(sizeof(v->evtchn_pending_sel)*2),
+                       v->evtchn_pending_sel);
+        }
+        v = per_cpu(xen_vcpu, cpu);
+
+        printk("\npending:\n   ");
+        for (i = ARRAY_SIZE(sh->evtchn_pending)-1; i >= 0; i--)
+                printk("%0*lx%s", (int)sizeof(sh->evtchn_pending[0])*2,
+                       sh->evtchn_pending[i],
+                       i % 8 == 0 ? "\n   " : " ");
+        printk("\nglobal mask:\n   ");
+        for (i = ARRAY_SIZE(sh->evtchn_mask)-1; i >= 0; i--)
+                printk("%0*lx%s",
+                       (int)(sizeof(sh->evtchn_mask[0])*2),
+                       sh->evtchn_mask[i],
+                       i % 8 == 0 ? "\n   " : " ");
+
+        printk("\nglobally unmasked:\n   ");
+        for (i = ARRAY_SIZE(sh->evtchn_mask)-1; i >= 0; i--)
+                printk("%0*lx%s", (int)(sizeof(sh->evtchn_mask[0])*2),
+                       sh->evtchn_pending[i] & ~sh->evtchn_mask[i],
+                       i % 8 == 0 ? "\n   " : " ");
+
+        printk("\nlocal cpu%d mask:\n   ", cpu);
+        for (i = (NR_EVENT_CHANNELS/BITS_PER_LONG)-1; i >= 0; i--)
+                printk("%0*lx%s", (int)(sizeof(cpu_evtchn[0])*2),
+                       cpu_evtchn[i],
+                       i % 8 == 0 ? "\n   " : " ");
+
+        printk("\nlocally unmasked:\n   ");
+        for (i = ARRAY_SIZE(sh->evtchn_mask)-1; i >= 0; i--) {
+                unsigned long pending = sh->evtchn_pending[i]
+                        & ~sh->evtchn_mask[i]
+                        & cpu_evtchn[i];
+                printk("%0*lx%s", (int)(sizeof(sh->evtchn_mask[0])*2),
+                       pending, i % 8 == 0 ? "\n   " : " ");
         }
-        printk("pending:\n   ");
-        for(i = ARRAY_SIZE(sh->evtchn_pending)-1; i >= 0; i--)
-                printk("%08lx%s", sh->evtchn_pending[i],
-                        i % 8 == 0 ? "\n   " : " ");
-        printk("\nmasks:\n   ");
-        for(i = ARRAY_SIZE(sh->evtchn_mask)-1; i >= 0; i--)
-                printk("%08lx%s", sh->evtchn_mask[i],
-                        i % 8 == 0 ? "\n   " : " ");
-
-        printk("\nunmasked:\n   ");
-        for(i = ARRAY_SIZE(sh->evtchn_mask)-1; i >= 0; i--)
-                printk("%08lx%s", sh->evtchn_pending[i] & ~sh->evtchn_mask[i],
-                        i % 8 == 0 ? "\n   " : " ");
 
         printk("\npending list:\n");
-        for(i = 0; i < NR_EVENT_CHANNELS; i++) {
+        for (i = 0; i < NR_EVENT_CHANNELS; i++) {
                 if (sync_test_bit(i, sh->evtchn_pending)) {
-                        printk("  %d: event %d -> irq %d\n",
+                        int word_idx = i / BITS_PER_LONG;
+                        printk("  %d: event %d -> irq %d%s%s%s\n",
                                cpu_from_evtchn(i), i,
-                               evtchn_to_irq[i]);
+                               evtchn_to_irq[i],
+                               sync_test_bit(word_idx, &v->evtchn_pending_sel)
+                                             ? "" : " l2-clear",
+                               !sync_test_bit(i, sh->evtchn_mask)
+                                             ? "" : " globally-masked",
+                               sync_test_bit(i, cpu_evtchn)
+                                             ? "" : " locally-masked");
                 }
         }
 
@@ -1077,6 +1111,9 @@ static void __xen_evtchn_do_upcall(void)
                                 int irq = evtchn_to_irq[port];
                                 struct irq_desc *desc;
 
+                                mask_evtchn(port);
+                                clear_evtchn(port);
+
                                 if (irq != -1) {
                                         desc = irq_to_desc(irq);
                                         if (desc)
@@ -1214,10 +1251,10 @@ static void ack_dynirq(unsigned int irq)
 {
         int evtchn = evtchn_from_irq(irq);
 
-        move_native_irq(irq);
+        move_masked_irq(irq);
 
         if (VALID_EVTCHN(evtchn))
-                clear_evtchn(evtchn);
+                unmask_evtchn(evtchn);
 }
 
 static int retrigger_dynirq(unsigned int irq)
@@ -1380,7 +1417,7 @@ static struct irq_chip xen_dynamic_chip __read_mostly = {
         .mask           = disable_dynirq,
         .unmask         = enable_dynirq,
 
-        .ack            = ack_dynirq,
+        .eoi            = ack_dynirq,
         .set_affinity   = set_affinity_irq,
         .retrigger      = retrigger_dynirq,
 };
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index 66e185cfe92f..fec6ba3c08a8 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -467,6 +467,7 @@ static const struct file_operations evtchn_fops = {
         .fasync  = evtchn_fasync,
         .open    = evtchn_open,
         .release = evtchn_release,
+        .llseek = noop_llseek,
 };
 
 static struct miscdevice evtchn_miscdev = {
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index d242610597c0..deb9c4ba3a93 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -64,9 +64,11 @@
 
 
 int xen_store_evtchn;
-EXPORT_SYMBOL(xen_store_evtchn);
+EXPORT_SYMBOL_GPL(xen_store_evtchn);
 
 struct xenstore_domain_interface *xen_store_interface;
+EXPORT_SYMBOL_GPL(xen_store_interface);
+
 static unsigned long xen_store_mfn;
 
 static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
diff --git a/drivers/xen/xenfs/Makefile b/drivers/xen/xenfs/Makefile
index 25275c3bbdff..4fde9440fe1f 100644
--- a/drivers/xen/xenfs/Makefile
+++ b/drivers/xen/xenfs/Makefile
@@ -1,3 +1,4 @@
 obj-$(CONFIG_XENFS) += xenfs.o
 
-xenfs-objs = super.o xenbus.o
\ No newline at end of file
+xenfs-y                   = super.o xenbus.o privcmd.o
+xenfs-$(CONFIG_XEN_DOM0) += xenstored.o
diff --git a/drivers/xen/xenfs/privcmd.c b/drivers/xen/xenfs/privcmd.c
new file mode 100644
index 000000000000..f80be7f6eb95
--- /dev/null
+++ b/drivers/xen/xenfs/privcmd.c
@@ -0,0 +1,404 @@
+/******************************************************************************
+ * privcmd.c
+ *
+ * Interface to privileged domain-0 commands.
+ *
+ * Copyright (c) 2002-2004, K A Fraser, B Dragovic
+ */
+
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+#include <linux/mm.h>
+#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>
+
+#include <asm/pgalloc.h>
+#include <asm/pgtable.h>
+#include <asm/tlb.h>
+#include <asm/xen/hypervisor.h>
+#include <asm/xen/hypercall.h>
+
+#include <xen/xen.h>
+#include <xen/privcmd.h>
+#include <xen/interface/xen.h>
+#include <xen/features.h>
+#include <xen/page.h>
+#include <xen/xen-ops.h>
+
+#ifndef HAVE_ARCH_PRIVCMD_MMAP
+static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma);
+#endif
+
+static long privcmd_ioctl_hypercall(void __user *udata)
+{
+        struct privcmd_hypercall hypercall;
+        long ret;
+
+        if (copy_from_user(&hypercall, udata, sizeof(hypercall)))
+                return -EFAULT;
+
+        ret = privcmd_call(hypercall.op,
+                           hypercall.arg[0], hypercall.arg[1],
+                           hypercall.arg[2], hypercall.arg[3],
+                           hypercall.arg[4]);
+
+        return ret;
+}
+
+static void free_page_list(struct list_head *pages)
+{
+        struct page *p, *n;
+
+        list_for_each_entry_safe(p, n, pages, lru)
+                __free_page(p);
+
+        INIT_LIST_HEAD(pages);
+}
+
+/*
+ * Given an array of items in userspace, return a list of pages
+ * containing the data.  If copying fails, either because of memory
+ * allocation failure or a problem reading user memory, return an
+ * error code; its up to the caller to dispose of any partial list.
+ */
+static int gather_array(struct list_head *pagelist,
+                        unsigned nelem, size_t size,
+                        void __user *data)
+{
+        unsigned pageidx;
+        void *pagedata;
+        int ret;
+
+        if (size > PAGE_SIZE)
+                return 0;
+
+        pageidx = PAGE_SIZE;
+        pagedata = NULL;        /* quiet, gcc */
+        while (nelem--) {
+                if (pageidx > PAGE_SIZE-size) {
+                        struct page *page = alloc_page(GFP_KERNEL);
+
+                        ret = -ENOMEM;
+                        if (page == NULL)
+                                goto fail;
+
+                        pagedata = page_address(page);
+
+                        list_add_tail(&page->lru, pagelist);
+                        pageidx = 0;
+                }
+
+                ret = -EFAULT;
+                if (copy_from_user(pagedata + pageidx, data, size))
+                        goto fail;
+
+                data += size;
+                pageidx += size;
+        }
+
+        ret = 0;
+
+fail:
+        return ret;
+}
+
+/*
+ * Call function "fn" on each element of the array fragmented
+ * over a list of pages.
+ */
+static int traverse_pages(unsigned nelem, size_t size,
+                          struct list_head *pos,
+                          int (*fn)(void *data, void *state),
+                          void *state)
+{
+        void *pagedata;
+        unsigned pageidx;
+        int ret = 0;
+
+        BUG_ON(size > PAGE_SIZE);
+
+        pageidx = PAGE_SIZE;
+        pagedata = NULL;        /* hush, gcc */
+
+        while (nelem--) {
+                if (pageidx > PAGE_SIZE-size) {
+                        struct page *page;
+                        pos = pos->next;
+                        page = list_entry(pos, struct page, lru);
+                        pagedata = page_address(page);
+                        pageidx = 0;
+                }
+
+                ret = (*fn)(pagedata + pageidx, state);
+                if (ret)
+                        break;
+                pageidx += size;
+        }
+
+        return ret;
+}
+
+struct mmap_mfn_state {
+        unsigned long va;
+        struct vm_area_struct *vma;
+        domid_t domain;
+};
+
+static int mmap_mfn_range(void *data, void *state)
+{
+        struct privcmd_mmap_entry *msg = data;
+        struct mmap_mfn_state *st = state;
+        struct vm_area_struct *vma = st->vma;
+        int rc;
+
+        /* Do not allow range to wrap the address space. */
+        if ((msg->npages > (LONG_MAX >> PAGE_SHIFT)) ||
+            ((unsigned long)(msg->npages << PAGE_SHIFT) >= -st->va))
+                return -EINVAL;
+
+        /* Range chunks must be contiguous in va space. */
+        if ((msg->va != st->va) ||
+            ((msg->va+(msg->npages<<PAGE_SHIFT)) > vma->vm_end))
+                return -EINVAL;
+
+        rc = xen_remap_domain_mfn_range(vma,
+                                        msg->va & PAGE_MASK,
+                                        msg->mfn, msg->npages,
+                                        vma->vm_page_prot,
+                                        st->domain);
+        if (rc < 0)
+                return rc;
+
+        st->va += msg->npages << PAGE_SHIFT;
+
+        return 0;
+}
+
+static long privcmd_ioctl_mmap(void __user *udata)
+{
+        struct privcmd_mmap mmapcmd;
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma;
+        int rc;
+        LIST_HEAD(pagelist);
+        struct mmap_mfn_state state;
+
+        if (!xen_initial_domain())
+                return -EPERM;
+
+        if (copy_from_user(&mmapcmd, udata, sizeof(mmapcmd)))
+                return -EFAULT;
+
+        rc = gather_array(&pagelist,
+                          mmapcmd.num, sizeof(struct privcmd_mmap_entry),
+                          mmapcmd.entry);
+
+        if (rc || list_empty(&pagelist))
+                goto out;
+
+        down_write(&mm->mmap_sem);
+
+        {
+                struct page *page = list_first_entry(&pagelist,
+                                                     struct page, lru);
+                struct privcmd_mmap_entry *msg = page_address(page);
+
+                vma = find_vma(mm, msg->va);
+                rc = -EINVAL;
+
+                if (!vma || (msg->va != vma->vm_start) ||
+                    !privcmd_enforce_singleshot_mapping(vma))
+                        goto out_up;
+        }
+
+        state.va = vma->vm_start;
+        state.vma = vma;
+        state.domain = mmapcmd.dom;
+
+        rc = traverse_pages(mmapcmd.num, sizeof(struct privcmd_mmap_entry),
+                            &pagelist,
+                            mmap_mfn_range, &state);
+
+
+out_up:
+        up_write(&mm->mmap_sem);
+
+out:
+        free_page_list(&pagelist);
+
+        return rc;
+}
+
+struct mmap_batch_state {
+        domid_t domain;
+        unsigned long va;
+        struct vm_area_struct *vma;
+        int err;
+
+        xen_pfn_t __user *user;
+};
+
+static int mmap_batch_fn(void *data, void *state)
+{
+        xen_pfn_t *mfnp = data;
+        struct mmap_batch_state *st = state;
+
+        if (xen_remap_domain_mfn_range(st->vma, st->va & PAGE_MASK, *mfnp, 1,
+                                       st->vma->vm_page_prot, st->domain) < 0) {
+                *mfnp |= 0xf0000000U;
+                st->err++;
+        }
+        st->va += PAGE_SIZE;
+
+        return 0;
+}
+
+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;
+}
+
+static struct vm_operations_struct privcmd_vm_ops;
+
+static long privcmd_ioctl_mmap_batch(void __user *udata)
+{
+        int ret;
+        struct privcmd_mmapbatch m;
+        struct mm_struct *mm = current->mm;
+        struct vm_area_struct *vma;
+        unsigned long nr_pages;
+        LIST_HEAD(pagelist);
+        struct mmap_batch_state state;
+
+        if (!xen_initial_domain())
+                return -EPERM;
+
+        if (copy_from_user(&m, udata, sizeof(m)))
+                return -EFAULT;
+
+        nr_pages = m.num;
+        if ((m.num <= 0) || (nr_pages > (LONG_MAX >> PAGE_SHIFT)))
+                return -EINVAL;
+
+        ret = gather_array(&pagelist, m.num, sizeof(xen_pfn_t),
+                           m.arr);
+
+        if (ret || list_empty(&pagelist))
+                goto out;
+
+        down_write(&mm->mmap_sem);
+
+        vma = find_vma(mm, m.addr);
+        ret = -EINVAL;
+        if (!vma ||
+            vma->vm_ops != &privcmd_vm_ops ||
+            (m.addr != vma->vm_start) ||
+            ((m.addr + (nr_pages << PAGE_SHIFT)) != vma->vm_end) ||
+            !privcmd_enforce_singleshot_mapping(vma)) {
+                up_write(&mm->mmap_sem);
+                goto out;
+        }
+
+        state.domain = m.dom;
+        state.vma = vma;
+        state.va = m.addr;
+        state.err = 0;
+
+        ret = traverse_pages(m.num, sizeof(xen_pfn_t),
+                             &pagelist, mmap_batch_fn, &state);
+
+        up_write(&mm->mmap_sem);
+
+        if (state.err > 0) {
+                ret = 0;
+
+                state.user = m.arr;
+                traverse_pages(m.num, sizeof(xen_pfn_t),
+                               &pagelist,
+                               mmap_return_errors, &state);
+        }
+
+out:
+        free_page_list(&pagelist);
+
+        return ret;
+}
+
+static long privcmd_ioctl(struct file *file,
+                          unsigned int cmd, unsigned long data)
+{
+        int ret = -ENOSYS;
+        void __user *udata = (void __user *) data;
+
+        switch (cmd) {
+        case IOCTL_PRIVCMD_HYPERCALL:
+                ret = privcmd_ioctl_hypercall(udata);
+                break;
+
+        case IOCTL_PRIVCMD_MMAP:
+                ret = privcmd_ioctl_mmap(udata);
+                break;
+
+        case IOCTL_PRIVCMD_MMAPBATCH:
+                ret = privcmd_ioctl_mmap_batch(udata);
+                break;
+
+        default:
+                ret = -EINVAL;
+                break;
+        }
+
+        return ret;
+}
+
+#ifndef HAVE_ARCH_PRIVCMD_MMAP
+static int privcmd_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
+{
+        printk(KERN_DEBUG "privcmd_fault: vma=%p %lx-%lx, pgoff=%lx, uv=%p\n",
+               vma, vma->vm_start, vma->vm_end,
+               vmf->pgoff, vmf->virtual_address);
+
+        return VM_FAULT_SIGBUS;
+}
+
+static struct vm_operations_struct privcmd_vm_ops = {
+        .fault = privcmd_fault
+};
+
+static int privcmd_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        /* Unsupported for auto-translate guests. */
+        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;
+        vma->vm_ops = &privcmd_vm_ops;
+        vma->vm_private_data = NULL;
+
+        return 0;
+}
+
+static int privcmd_enforce_singleshot_mapping(struct vm_area_struct *vma)
+{
+        return (xchg(&vma->vm_private_data, (void *)1) == NULL);
+}
+#endif
+
+const struct file_operations privcmd_file_ops = {
+        .unlocked_ioctl = privcmd_ioctl,
+        .mmap = privcmd_mmap,
+};
diff --git a/drivers/xen/xenfs/super.c b/drivers/xen/xenfs/super.c
index 78bfab0700ba..d6662b789b6b 100644
--- a/drivers/xen/xenfs/super.c
+++ b/drivers/xen/xenfs/super.c
@@ -12,6 +12,8 @@
 #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>
 
@@ -22,6 +24,62 @@
 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;
+        }
+        return ret;
+}
+
+static struct dentry *xenfs_create_file(struct super_block *sb,
+                                        struct dentry *parent,
+                                        const char *name,
+                                        const struct file_operations *fops,
+                                        void *data,
+                                        int mode)
+{
+        struct dentry *dentry;
+        struct inode *inode;
+
+        dentry = d_alloc_name(parent, name);
+        if (!dentry)
+                return NULL;
+
+        inode = xenfs_make_inode(sb, S_IFREG | mode);
+        if (!inode) {
+                dput(dentry);
+                return NULL;
+        }
+
+        inode->i_fop = fops;
+        inode->i_private = data;
+
+        d_add(dentry, inode);
+        return dentry;
+}
+
 static ssize_t capabilities_read(struct file *file, char __user *buf,
                                  size_t size, loff_t *off)
 {
@@ -35,6 +93,7 @@ static ssize_t capabilities_read(struct file *file, char __user *buf,
 
 static const struct file_operations capabilities_file_ops = {
         .read = capabilities_read,
+        .llseek = default_llseek,
 };
 
 static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
@@ -43,10 +102,23 @@ static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
                 [1] = {},
                 { "xenbus", &xenbus_file_ops, S_IRUSR|S_IWUSR },
                 { "capabilities", &capabilities_file_ops, S_IRUGO },
+                { "privcmd", &privcmd_file_ops, S_IRUSR|S_IWUSR },
                 {""},
         };
+        int rc;
 
-        return simple_fill_super(sb, XENFS_SUPER_MAGIC, xenfs_files);
+        rc = simple_fill_super(sb, XENFS_SUPER_MAGIC, xenfs_files);
+        if (rc < 0)
+                return rc;
+
+        if (xen_initial_domain()) {
+                xenfs_create_file(sb, sb->s_root, "xsd_kva",
+                                  &xsd_kva_file_ops, NULL, S_IRUSR|S_IWUSR);
+                xenfs_create_file(sb, sb->s_root, "xsd_port",
+                                  &xsd_port_file_ops, NULL, S_IRUSR|S_IWUSR);
+        }
+
+        return rc;
 }
 
 static int xenfs_get_sb(struct file_system_type *fs_type,
@@ -65,11 +137,25 @@ static struct file_system_type xenfs_type = {
 
 static int __init xenfs_init(void)
 {
-        if (xen_domain())
-                return register_filesystem(&xenfs_type);
+        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:
 
-        printk(KERN_INFO "XENFS: not registering filesystem on non-xen platform\n");
-        return 0;
+        return err;
 }
 
 static void __exit xenfs_exit(void)
diff --git a/drivers/xen/xenfs/xenbus.c b/drivers/xen/xenfs/xenbus.c
index 3b39c3752e21..1c1236087f78 100644
--- a/drivers/xen/xenfs/xenbus.c
+++ b/drivers/xen/xenfs/xenbus.c
@@ -594,4 +594,5 @@ const struct file_operations xenbus_file_ops = {
         .open = xenbus_file_open,
         .release = xenbus_file_release,
         .poll = xenbus_file_poll,
+        .llseek = no_llseek,
 };
diff --git a/drivers/xen/xenfs/xenfs.h b/drivers/xen/xenfs/xenfs.h
index 51f08b2d0bf1..b68aa6200003 100644
--- a/drivers/xen/xenfs/xenfs.h
+++ b/drivers/xen/xenfs/xenfs.h
@@ -2,5 +2,8 @@
 #define _XENFS_XENBUS_H
 
 extern const struct file_operations xenbus_file_ops;
+extern const struct file_operations privcmd_file_ops;
+extern const struct file_operations xsd_kva_file_ops;
+extern const struct file_operations xsd_port_file_ops;
 
 #endif  /* _XENFS_XENBUS_H */
diff --git a/drivers/xen/xenfs/xenstored.c b/drivers/xen/xenfs/xenstored.c
new file mode 100644
index 000000000000..fef20dbc6a5c
--- /dev/null
+++ b/drivers/xen/xenfs/xenstored.c
@@ -0,0 +1,68 @@
+#include <linux/slab.h>
+#include <linux/types.h>
+#include <linux/mm.h>
+#include <linux/fs.h>
+
+#include <xen/page.h>
+
+#include "xenfs.h"
+#include "../xenbus/xenbus_comms.h"
+
+static ssize_t xsd_read(struct file *file, char __user *buf,
+                            size_t size, loff_t *off)
+{
+        const char *str = (const char *)file->private_data;
+        return simple_read_from_buffer(buf, size, off, str, strlen(str));
+}
+
+static int xsd_release(struct inode *inode, struct file *file)
+{
+        kfree(file->private_data);
+        return 0;
+}
+
+static int xsd_kva_open(struct inode *inode, struct file *file)
+{
+        file->private_data = (void *)kasprintf(GFP_KERNEL, "0x%p",
+                                               xen_store_interface);
+        if (!file->private_data)
+                return -ENOMEM;
+        return 0;
+}
+
+static int xsd_kva_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        size_t size = vma->vm_end - vma->vm_start;
+
+        if ((size > PAGE_SIZE) || (vma->vm_pgoff != 0))
+                return -EINVAL;
+
+        if (remap_pfn_range(vma, vma->vm_start,
+                            virt_to_pfn(xen_store_interface),
+                            size, vma->vm_page_prot))
+                return -EAGAIN;
+
+        return 0;
+}
+
+const struct file_operations xsd_kva_file_ops = {
+        .open = xsd_kva_open,
+        .mmap = xsd_kva_mmap,
+        .read = xsd_read,
+        .release = xsd_release,
+};
+
+static int xsd_port_open(struct inode *inode, struct file *file)
+{
+        file->private_data = (void *)kasprintf(GFP_KERNEL, "%d",
+                                               xen_store_evtchn);
+        if (!file->private_data)
+                return -ENOMEM;
+        return 0;
+}
+
+const struct file_operations xsd_port_file_ops = {
+        .open = xsd_port_open,
+        .read = xsd_read,
+        .release = xsd_release,
+};