50 files changed, 757 insertions, 5464 deletions
diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index cabfa97f467..5f7ff8e2fc1 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -3,7 +3,6 @@ menu "Xen driver support"
 config XEN_BALLOON
        bool "Xen memory balloon driver"
-        depends on !ARM
        default y
        help
          The balloon driver allows the Xen domain to request more memory from
@@ -72,7 +71,7 @@ config XEN_DEV_EVTCHN
        tristate "Xen /dev/xen/evtchn device"
        default y
        help
-          The evtchn driver allows a userspace process to trigger event
+          The evtchn driver allows a userspace process to triger event
          channels and to receive notification of an event channel
          firing.
          If in doubt, say yes.
@@ -87,7 +86,6 @@ config XEN_BACKEND
 config XENFS
        tristate "Xen filesystem"
-        select XEN_PRIVCMD
        default y
        help
          The xen filesystem provides a way for domains to share
@@ -139,6 +137,16 @@ config XEN_GRANT_DEV_ALLOC
          to other domains. This can be used to implement frontend drivers
          or as part of an inter-domain shared memory channel.
+config XEN_PLATFORM_PCI
+        tristate "xen platform pci device driver"
+        depends on XEN_PVHVM && PCI
+        default m
+        help
+          Driver for the Xen PCI Platform device: it is responsible for
+          initializing xenbus and grant_table when running in a Xen HVM
+          domain. As a consequence this driver is required to run any Xen PV
+          frontend on Xen HVM.
 config SWIOTLB_XEN
        def_bool y
        depends on PCI
@@ -146,7 +154,6 @@ config SWIOTLB_XEN
 config XEN_TMEM
        bool
-        depends on !ARM
        default y if (CLEANCACHE || FRONTSWAP)
        help
          Shim to interface in-kernel Transcendent Memory hooks
@@ -174,39 +181,4 @@ config XEN_PCIDEV_BACKEND
          xen-pciback.hide=(03:00.0)(04:00.0)
          If in doubt, say m.
-config XEN_PRIVCMD
-        tristate
-        depends on XEN
-        default m
-config XEN_ACPI_PROCESSOR
-        tristate "Xen ACPI processor"
-        depends on XEN && X86 && ACPI_PROCESSOR && CPU_FREQ
-        default m
-        help
-          This ACPI processor uploads Power Management information to the Xen
-          hypervisor.
-          To do that the driver parses the Power Management data and uploads
-          said information to the Xen hypervisor. Then the Xen hypervisor can
-          select the proper Cx and Pxx states. It also registers itslef as the
-          SMM so that other drivers (such as ACPI cpufreq scaling driver) will
-          not load.
-          To compile this driver as a module, choose M here: the module will be
-          called xen_acpi_processor  If you do not know what to choose, select
-          M here. If the CPUFREQ drivers are built in, select Y here.
-config XEN_MCE_LOG
-        bool "Xen platform mcelog"
-        depends on XEN_DOM0 && X86_64 && X86_MCE
-        default n
-        help
-          Allow kernel fetching MCE error from Xen platform and
-          converting it into Linux mcelog format for mcelog tools
-config XEN_HAVE_PVMMU
-       bool
 endmenu
diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index fb213cf81a7..72bbb27d7a6 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -1,21 +1,11 @@
-ifneq ($(CONFIG_ARM),y)
+obj-y   += grant-table.o features.o events.o manage.o balloon.o
-obj-y   += manage.o
-obj-$(CONFIG_HOTPLUG_CPU)               += cpu_hotplug.o
-endif
-obj-$(CONFIG_X86)                       += fallback.o
-obj-y   += grant-table.o features.o events.o balloon.o
 obj-y   += xenbus/
 nostackp := $(call cc-option, -fno-stack-protector)
 CFLAGS_features.o                       := $(nostackp)
-dom0-$(CONFIG_PCI) += pci.o
-dom0-$(CONFIG_USB_SUPPORT) += dbgp.o
-dom0-$(CONFIG_ACPI) += acpi.o $(xen-pad-y)
-xen-pad-$(CONFIG_X86) += xen-acpi-pad.o
-dom0-$(CONFIG_X86) += pcpu.o
-obj-$(CONFIG_XEN_DOM0)                  += $(dom0-y)
 obj-$(CONFIG_BLOCK)                     += biomerge.o
+obj-$(CONFIG_HOTPLUG_CPU)               += cpu_hotplug.o
 obj-$(CONFIG_XEN_XENCOMM)               += xencomm.o
 obj-$(CONFIG_XEN_BALLOON)               += xen-balloon.o
 obj-$(CONFIG_XEN_SELFBALLOONING)        += xen-selfballoon.o
@@ -24,14 +14,14 @@ obj-$(CONFIG_XEN_GNTDEV)		+= xen-gntdev.o
 obj-$(CONFIG_XEN_GRANT_DEV_ALLOC)       += xen-gntalloc.o
 obj-$(CONFIG_XENFS)                     += xenfs/
 obj-$(CONFIG_XEN_SYS_HYPERVISOR)        += sys-hypervisor.o
-obj-$(CONFIG_XEN_PVHVM)                 += platform-pci.o
+obj-$(CONFIG_XEN_PLATFORM_PCI)          += xen-platform-pci.o
 obj-$(CONFIG_XEN_TMEM)                  += tmem.o
 obj-$(CONFIG_SWIOTLB_XEN)               += swiotlb-xen.o
-obj-$(CONFIG_XEN_MCE_LOG)               += mcelog.o
+obj-$(CONFIG_XEN_DOM0)                  += pci.o
 obj-$(CONFIG_XEN_PCIDEV_BACKEND)        += xen-pciback/
-obj-$(CONFIG_XEN_PRIVCMD)               += xen-privcmd.o
-obj-$(CONFIG_XEN_ACPI_PROCESSOR)        += xen-acpi-processor.o
 xen-evtchn-y                            := evtchn.o
 xen-gntdev-y                            := gntdev.o
 xen-gntalloc-y                          := gntalloc.o
-xen-privcmd-y                           := privcmd.o
+xen-platform-pci-y                      := platform-pci.o
diff --git a/drivers/xen/acpi.c b/drivers/xen/acpi.c
deleted file mode 100644
index 119d42a2bf5..00000000000
--- a/drivers/xen/acpi.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/******************************************************************************
- * acpi.c
- * acpi file for domain 0 kernel
- *
- * Copyright (c) 2011 Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
- * Copyright (c) 2011 Yu Ke ke.yu@intel.com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include <xen/acpi.h>
-#include <xen/interface/platform.h>
-#include <asm/xen/hypercall.h>
-#include <asm/xen/hypervisor.h>
-int xen_acpi_notify_hypervisor_state(u8 sleep_state,
-                                     u32 pm1a_cnt, u32 pm1b_cnt)
-{
-        struct xen_platform_op op = {
-                .cmd = XENPF_enter_acpi_sleep,
-                .interface_version = XENPF_INTERFACE_VERSION,
-                .u = {
-                        .enter_acpi_sleep = {
-                                .pm1a_cnt_val = (u16)pm1a_cnt,
-                                .pm1b_cnt_val = (u16)pm1b_cnt,
-                                .sleep_state = sleep_state,
-                        },
-                },
-        };
-        if ((pm1a_cnt & 0xffff0000) || (pm1b_cnt & 0xffff0000)) {
-                WARN(1, "Using more than 16bits of PM1A/B 0x%x/0x%x!"
-                     "Email xen-devel@lists.xensource.com  Thank you.\n", \
-                     pm1a_cnt, pm1b_cnt);
-                return -1;
-        }
-        HYPERVISOR_dom0_op(&op);
-        return 1;
-}
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index a56776dbe09..5dfd8f8ff07 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -39,7 +39,6 @@
 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/bootmem.h>
 #include <linux/pagemap.h>
@@ -55,6 +54,7 @@
 #include <asm/pgalloc.h>
 #include <asm/pgtable.h>
 #include <asm/tlb.h>
+#include <asm/e820.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
@@ -87,14 +87,14 @@ struct balloon_stats balloon_stats;
 EXPORT_SYMBOL_GPL(balloon_stats);
 /* We increase/decrease in batches which fit in a page */
-static xen_pfn_t frame_list[PAGE_SIZE / sizeof(unsigned long)];
+static unsigned long frame_list[PAGE_SIZE / sizeof(unsigned long)];
 #ifdef CONFIG_HIGHMEM
 #define inc_totalhigh_pages() (totalhigh_pages++)
 #define dec_totalhigh_pages() (totalhigh_pages--)
 #else
-#define inc_totalhigh_pages() do {} while (0)
+#define inc_totalhigh_pages() do {} while(0)
-#define dec_totalhigh_pages() do {} while (0)
+#define dec_totalhigh_pages() do {} while(0)
 #endif
 /* List of ballooned pages, threaded through the mem_map array. */
@@ -154,7 +154,8 @@ static struct page *balloon_retrieve(bool prefer_highmem)
        if (PageHighMem(page)) {
                balloon_stats.balloon_high--;
                inc_totalhigh_pages();
-        } else
+        }
+        else
                balloon_stats.balloon_low--;
        totalram_pages++;
@@ -359,7 +360,6 @@ static enum bp_state increase_reservation(unsigned long nr_pages)
                set_phys_to_machine(pfn, frame_list[i]);
-#ifdef CONFIG_XEN_HAVE_PVMMU
                /* Link back into the page tables if not highmem. */
                if (xen_pv_domain() && !PageHighMem(page)) {
                        int ret;
@@ -369,7 +369,6 @@ static enum bp_state increase_reservation(unsigned long nr_pages)
                                0);
                        BUG_ON(ret);
                }
-#endif
                /* Relinquish the page back to the allocator. */
                ClearPageReserved(page);
@@ -418,14 +417,13 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp)
                scrub_page(page);
-#ifdef CONFIG_XEN_HAVE_PVMMU
                if (xen_pv_domain() && !PageHighMem(page)) {
                        ret = HYPERVISOR_update_va_mapping(
                                (unsigned long)__va(pfn << PAGE_SHIFT),
                                __pte_ma(0), 0);
                        BUG_ON(ret);
-                }
+                }
-#endif
        }
        /* Ensure that ballooned highmem pages don't have kmaps. */
@@ -503,24 +501,20 @@ EXPORT_SYMBOL_GPL(balloon_set_new_target);
 * alloc_xenballooned_pages - get pages that have been ballooned out
 * @nr_pages: Number of pages to get
 * @pages: pages returned
- * @highmem: allow highmem pages
 * @return 0 on success, error otherwise
 */
-int alloc_xenballooned_pages(int nr_pages, struct page **pages, bool highmem)
+int alloc_xenballooned_pages(int nr_pages, struct page** pages)
 {
        int pgno = 0;
-        struct page *page;
+        struct page* page;
        mutex_lock(&balloon_mutex);
        while (pgno < nr_pages) {
-                page = balloon_retrieve(highmem);
+                page = balloon_retrieve(true);
-                if (page && (highmem || !PageHighMem(page))) {
+                if (page) {
                        pages[pgno++] = page;
                } else {
                        enum bp_state st;
-                        if (page)
+                        st = decrease_reservation(nr_pages - pgno, GFP_HIGHUSER);
-                                balloon_append(page);
-                        st = decrease_reservation(nr_pages - pgno,
-                                        highmem ? GFP_HIGHUSER : GFP_USER);
                        if (st != BP_DONE)
                                goto out_undo;
                }
@@ -542,7 +536,7 @@ EXPORT_SYMBOL(alloc_xenballooned_pages);
 * @nr_pages: Number of pages
 * @pages: pages to return
 */
-void free_xenballooned_pages(int nr_pages, struct page **pages)
+void free_xenballooned_pages(int nr_pages, struct page** pages)
 {
        int i;
@@ -561,40 +555,17 @@ void free_xenballooned_pages(int nr_pages, struct page **pages)
 }
 EXPORT_SYMBOL(free_xenballooned_pages);
-static void __init balloon_add_region(unsigned long start_pfn,
+static int __init balloon_init(void)
-                                      unsigned long pages)
 {
        unsigned long pfn, extra_pfn_end;
        struct page *page;
-        /*
-         * If the amount of usable memory has been limited (e.g., with
-         * the 'mem' command line parameter), don't add pages beyond
-         * this limit.
-         */
-        extra_pfn_end = min(max_pfn, start_pfn + pages);
-        for (pfn = start_pfn; pfn < extra_pfn_end; pfn++) {
-                page = pfn_to_page(pfn);
-                /* totalram_pages and totalhigh_pages do not
-                   include the boot-time balloon extension, so
-                   don't subtract from it. */
-                __balloon_append(page);
-        }
-}
-static int __init balloon_init(void)
-{
-        int i;
        if (!xen_domain())
                return -ENODEV;
        pr_info("xen/balloon: Initialising balloon driver.\n");
-        balloon_stats.current_pages = xen_pv_domain()
+        balloon_stats.current_pages = xen_pv_domain() ? min(xen_start_info->nr_pages, max_pfn) : max_pfn;
-                ? min(xen_start_info->nr_pages - xen_released_pages, max_pfn)
-                : max_pfn;
        balloon_stats.target_pages  = balloon_stats.current_pages;
        balloon_stats.balloon_low   = 0;
        balloon_stats.balloon_high  = 0;
@@ -613,13 +584,24 @@ static int __init balloon_init(void)
 #endif
        /*
-         * Initialize the balloon with pages from the extra memory
+         * Initialise the balloon with excess memory space.  We need
-         * regions (see arch/x86/xen/setup.c).
+         * to make sure we don't add memory which doesn't exist or
+         * logically exist.  The E820 map can be trimmed to be smaller
+         * than the amount of physical memory due to the mem= command
+         * line parameter.  And if this is a 32-bit non-HIGHMEM kernel
+         * on a system with memory which requires highmem to access,
+         * don't try to use it.
         */
-        for (i = 0; i < XEN_EXTRA_MEM_MAX_REGIONS; i++)
+        extra_pfn_end = min(min(max_pfn, e820_end_of_ram_pfn()),
-                if (xen_extra_mem[i].size)
+                            (unsigned long)PFN_DOWN(xen_extra_mem_start + xen_extra_mem_size));
-                        balloon_add_region(PFN_UP(xen_extra_mem[i].start),
+        for (pfn = PFN_UP(xen_extra_mem_start);
-                                           PFN_DOWN(xen_extra_mem[i].size));
+             pfn < extra_pfn_end;
+             pfn++) {
+                page = pfn_to_page(pfn);
+                /* totalram_pages and totalhigh_pages do not include the boot-time
+                   balloon extension, so don't subtract from it. */
+                __balloon_append(page);
+        }
        return 0;
 }
diff --git a/drivers/xen/biomerge.c b/drivers/xen/biomerge.c
index 0edb91c0de6..ba6eda4b514 100644
--- a/drivers/xen/biomerge.c
+++ b/drivers/xen/biomerge.c
@@ -1,6 +1,5 @@
 #include <linux/bio.h>
 #include <linux/io.h>
-#include <linux/export.h>
 #include <xen/page.h>
 bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
@@ -12,4 +11,3 @@ bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
        return __BIOVEC_PHYS_MERGEABLE(vec1, vec2) &&
                ((mfn1 == mfn2) || ((mfn1+1) == mfn2));
 }
-EXPORT_SYMBOL(xen_biovec_phys_mergeable);
diff --git a/drivers/xen/cpu_hotplug.c b/drivers/xen/cpu_hotplug.c
index 4dcfced107f..14e2d995e95 100644
--- a/drivers/xen/cpu_hotplug.c
+++ b/drivers/xen/cpu_hotplug.c
@@ -30,8 +30,7 @@ static int vcpu_online(unsigned int cpu)
        sprintf(dir, "cpu/%u", cpu);
        err = xenbus_scanf(XBT_NIL, dir, "availability", "%s", state);
        if (err != 1) {
-                if (!xen_initial_domain())
+                printk(KERN_ERR "XENBUS: Unable to read cpu state\n");
-                        printk(KERN_ERR "XENBUS: Unable to read cpu state\n");
                return err;
        }
diff --git a/drivers/xen/dbgp.c b/drivers/xen/dbgp.c
deleted file mode 100644
index f3ccc80a455..00000000000
--- a/drivers/xen/dbgp.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <linux/pci.h>
-#include <linux/usb.h>
-#include <linux/usb/ehci_def.h>
-#include <linux/usb/hcd.h>
-#include <asm/xen/hypercall.h>
-#include <xen/interface/physdev.h>
-#include <xen/xen.h>
-static int xen_dbgp_op(struct usb_hcd *hcd, int op)
-{
-#ifdef CONFIG_PCI
-        const struct device *ctrlr = hcd_to_bus(hcd)->controller;
-#endif
-        struct physdev_dbgp_op dbgp;
-        if (!xen_initial_domain())
-                return 0;
-        dbgp.op = op;
-#ifdef CONFIG_PCI
-        if (ctrlr->bus == &pci_bus_type) {
-                const struct pci_dev *pdev = to_pci_dev(ctrlr);
-                dbgp.u.pci.seg = pci_domain_nr(pdev->bus);
-                dbgp.u.pci.bus = pdev->bus->number;
-                dbgp.u.pci.devfn = pdev->devfn;
-                dbgp.bus = PHYSDEVOP_DBGP_BUS_PCI;
-        } else
-#endif
-                dbgp.bus = PHYSDEVOP_DBGP_BUS_UNKNOWN;
-        return HYPERVISOR_physdev_op(PHYSDEVOP_dbgp_op, &dbgp);
-}
-int xen_dbgp_reset_prep(struct usb_hcd *hcd)
-{
-        return xen_dbgp_op(hcd, PHYSDEVOP_DBGP_RESET_PREPARE);
-}
-int xen_dbgp_external_startup(struct usb_hcd *hcd)
-{
-        return xen_dbgp_op(hcd, PHYSDEVOP_DBGP_RESET_DONE);
-}
-#ifndef CONFIG_EARLY_PRINTK_DBGP
-#include <linux/export.h>
-EXPORT_SYMBOL_GPL(xen_dbgp_reset_prep);
-EXPORT_SYMBOL_GPL(xen_dbgp_external_startup);
-#endif
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 0be4df39e95..44490de5aec 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -31,16 +31,13 @@
 #include <linux/irqnr.h>
 #include <linux/pci.h>
-#ifdef CONFIG_X86
 #include <asm/desc.h>
 #include <asm/ptrace.h>
 #include <asm/irq.h>
 #include <asm/idle.h>
 #include <asm/io_apic.h>
-#include <asm/xen/page.h>
-#include <asm/xen/pci.h>
-#endif
 #include <asm/sync_bitops.h>
+#include <asm/xen/pci.h>
 #include <asm/xen/hypercall.h>
 #include <asm/xen/hypervisor.h>
@@ -52,9 +49,6 @@
 #include <xen/interface/event_channel.h>
 #include <xen/interface/hvm/hvm_op.h>
 #include <xen/interface/hvm/params.h>
-#include <xen/interface/physdev.h>
-#include <xen/interface/sched.h>
-#include <asm/hw_irq.h>
 /*
 * This lock protects updates to the following mapping and reference-count
@@ -91,9 +85,9 @@ enum xen_irq_type {
 *    IPI - IPI vector
 *    EVTCHN -
 */
-struct irq_info {
+struct irq_info
+{
        struct list_head list;
-        int refcnt;
        enum xen_irq_type type; /* type */
        unsigned irq;
        unsigned short evtchn;  /* event channel */
@@ -115,10 +109,6 @@ struct irq_info {
 #define PIRQ_SHAREABLE  (1 << 1)
 static int *evtchn_to_irq;
-#ifdef CONFIG_X86
-static unsigned long *pirq_eoi_map;
-#endif
-static bool (*pirq_needs_eoi)(unsigned irq);
 static DEFINE_PER_CPU(unsigned long [NR_EVENT_CHANNELS/BITS_PER_LONG],
                      cpu_evtchn_mask);
@@ -279,16 +269,10 @@ static unsigned int cpu_from_evtchn(unsigned int evtchn)
        return ret;
 }
-#ifdef CONFIG_X86
+static bool pirq_needs_eoi(unsigned irq)
-static bool pirq_check_eoi_map(unsigned irq)
-{
-        return test_bit(pirq_from_irq(irq), pirq_eoi_map);
-}
-#endif
-static bool pirq_needs_eoi_flag(unsigned irq)
 {
        struct irq_info *info = info_for_irq(irq);
        BUG_ON(info->type != IRQT_PIRQ);
        return info->u.pirq.flags & PIRQ_NEEDS_EOI;
@@ -298,9 +282,9 @@ static inline unsigned long active_evtchns(unsigned int cpu,
                                           struct shared_info *sh,
                                           unsigned int idx)
 {
-        return sh->evtchn_pending[idx] &
+        return (sh->evtchn_pending[idx] &
                per_cpu(cpu_evtchn_mask, cpu)[idx] &
-                ~sh->evtchn_mask[idx];
+                ~sh->evtchn_mask[idx]);
 }
 static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
@@ -382,22 +366,11 @@ static void unmask_evtchn(int port)
 {
        struct shared_info *s = HYPERVISOR_shared_info;
        unsigned int cpu = get_cpu();
-        int do_hypercall = 0, evtchn_pending = 0;
        BUG_ON(!irqs_disabled());
-        if (unlikely((cpu != cpu_from_evtchn(port))))
+        /* Slow path (hypercall) if this is a non-local port. */
-                do_hypercall = 1;
+        if (unlikely(cpu != cpu_from_evtchn(port))) {
-        else
-                evtchn_pending = sync_test_bit(port, &s->evtchn_pending[0]);
-        if (unlikely(evtchn_pending && xen_hvm_domain()))
-                do_hypercall = 1;
-        /* Slow path (hypercall) if this is a non-local port or if this is
-         * an hvm domain and an event is pending (hvm domains don't have
-         * their own implementation of irq_enable). */
-        if (do_hypercall) {
                struct evtchn_unmask unmask = { .port = port };
                (void)HYPERVISOR_event_channel_op(EVTCHNOP_unmask, &unmask);
        } else {
@@ -410,7 +383,7 @@ static void unmask_evtchn(int port)
                 * 'hw_resend_irq'. Just like a real IO-APIC we 'lose
                 * the interrupt edge' if the channel is masked.
                 */
-                if (evtchn_pending &&
+                if (sync_test_bit(port, &s->evtchn_pending[0]) &&
                    !sync_test_and_set_bit(port / BITS_PER_LONG,
                                           &vcpu_info->evtchn_pending_sel))
                        vcpu_info->evtchn_upcall_pending = 1;
@@ -434,7 +407,6 @@ static void xen_irq_init(unsigned irq)
                panic("Unable to allocate metadata for IRQ%d\n", irq);
        info->type = IRQT_UNBOUND;
-        info->refcnt = -1;
        irq_set_handler_data(irq, info);
@@ -460,8 +432,7 @@ static int __must_check xen_allocate_irq_dynamic(void)
        irq = irq_alloc_desc_from(first, -1);
-        if (irq >= 0)
+        xen_irq_init(irq);
-                xen_irq_init(irq);
        return irq;
 }
@@ -498,8 +469,6 @@ static void xen_free_irq(unsigned irq)
        irq_set_handler_data(irq, NULL);
-        WARN_ON(info->refcnt > 0);
        kfree(info);
        /* Legacy IRQ descriptors are managed by the arch. */
@@ -631,7 +600,7 @@ static void disable_pirq(struct irq_data *data)
        disable_dynirq(data);
 }
-int xen_irq_from_gsi(unsigned gsi)
+static int find_irq_by_gsi(unsigned gsi)
 {
        struct irq_info *info;
@@ -645,7 +614,6 @@ int xen_irq_from_gsi(unsigned gsi)
        return -1;
 }
-EXPORT_SYMBOL_GPL(xen_irq_from_gsi);
 /*
 * Do not make any assumptions regarding the relationship between the
@@ -665,11 +633,11 @@ int xen_bind_pirq_gsi_to_irq(unsigned gsi,
        mutex_lock(&irq_mapping_update_lock);
-        irq = xen_irq_from_gsi(gsi);
+        irq = find_irq_by_gsi(gsi);
        if (irq != -1) {
                printk(KERN_INFO "xen_map_pirq_gsi: returning irq %d for gsi %u\n",
                       irq, gsi);
-                goto out;
+                goto out;       /* XXX need refcount? */
        }
        irq = xen_allocate_irq_gsi(gsi);
@@ -745,7 +713,7 @@ int xen_bind_pirq_msi_to_irq(struct pci_dev *dev, struct msi_desc *msidesc,
        mutex_lock(&irq_mapping_update_lock);
        irq = xen_allocate_irq_dynamic();
-        if (irq < 0)
+        if (irq == -1)
                goto out;
        irq_set_chip_and_handler_name(irq, &xen_pirq_chip, handle_edge_irq,
@@ -761,7 +729,7 @@ out:
 error_irq:
        mutex_unlock(&irq_mapping_update_lock);
        xen_free_irq(irq);
-        return ret;
+        return -1;
 }
 #endif
@@ -811,7 +779,7 @@ int xen_irq_from_pirq(unsigned pirq)
        mutex_lock(&irq_mapping_update_lock);
        list_for_each_entry(info, &xen_irq_list_head, list) {
-                if (info->type != IRQT_PIRQ)
+                if (info == NULL || info->type != IRQT_PIRQ)
                        continue;
                irq = info->irq;
                if (info->u.pirq.pirq == pirq)
@@ -847,11 +815,7 @@ int bind_evtchn_to_irq(unsigned int evtchn)
                                              handle_edge_irq, "event");
                xen_irq_info_evtchn_init(irq, evtchn);
-        } else {
-                struct irq_info *info = info_for_irq(irq);
-                WARN_ON(info == NULL || info->type != IRQT_EVTCHN);
        }
-        irq_clear_status_flags(irq, IRQ_NOREQUEST|IRQ_NOAUTOEN);
 out:
        mutex_unlock(&irq_mapping_update_lock);
@@ -886,9 +850,6 @@ static int bind_ipi_to_irq(unsigned int ipi, unsigned int cpu)
                xen_irq_info_ipi_init(cpu, irq, evtchn, ipi);
                bind_evtchn_to_cpu(evtchn, cpu);
-        } else {
-                struct irq_info *info = info_for_irq(irq);
-                WARN_ON(info == NULL || info->type != IRQT_IPI);
        }
 out:
@@ -911,32 +872,11 @@ static int bind_interdomain_evtchn_to_irq(unsigned int remote_domain,
        return err ? : bind_evtchn_to_irq(bind_interdomain.local_port);
 }
-static int find_virq(unsigned int virq, unsigned int cpu)
-{
-        struct evtchn_status status;
-        int port, rc = -ENOENT;
-        memset(&status, 0, sizeof(status));
-        for (port = 0; port <= NR_EVENT_CHANNELS; port++) {
-                status.dom = DOMID_SELF;
-                status.port = port;
-                rc = HYPERVISOR_event_channel_op(EVTCHNOP_status, &status);
-                if (rc < 0)
-                        continue;
-                if (status.status != EVTCHNSTAT_virq)
-                        continue;
-                if (status.u.virq == virq && status.vcpu == cpu) {
-                        rc = port;
-                        break;
-                }
-        }
-        return rc;
-}
 int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
 {
        struct evtchn_bind_virq bind_virq;
-        int evtchn, irq, ret;
+        int evtchn, irq;
        mutex_lock(&irq_mapping_update_lock);
@@ -952,23 +892,14 @@ int bind_virq_to_irq(unsigned int virq, unsigned int cpu)
                bind_virq.virq = virq;
                bind_virq.vcpu = cpu;
-                ret = HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
+                if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
-                                                &bind_virq);
+                                                &bind_virq) != 0)
-                if (ret == 0)
+                        BUG();
-                        evtchn = bind_virq.port;
+                evtchn = bind_virq.port;
-                else {
-                        if (ret == -EEXIST)
-                                ret = find_virq(virq, cpu);
-                        BUG_ON(ret < 0);
-                        evtchn = ret;
-                }
                xen_irq_info_virq_init(cpu, irq, evtchn, virq);
                bind_evtchn_to_cpu(evtchn, cpu);
-        } else {
-                struct irq_info *info = info_for_irq(irq);
-                WARN_ON(info == NULL || info->type != IRQT_VIRQ);
        }
 out:
@@ -981,16 +912,9 @@ static void unbind_from_irq(unsigned int irq)
 {
        struct evtchn_close close;
        int evtchn = evtchn_from_irq(irq);
-        struct irq_info *info = irq_get_handler_data(irq);
        mutex_lock(&irq_mapping_update_lock);
-        if (info->refcnt > 0) {
-                info->refcnt--;
-                if (info->refcnt != 0)
-                        goto done;
-        }
        if (VALID_EVTCHN(evtchn)) {
                close.port = evtchn;
                if (HYPERVISOR_event_channel_op(EVTCHNOP_close, &close) != 0)
@@ -1019,7 +943,6 @@ static void unbind_from_irq(unsigned int irq)
        xen_free_irq(irq);
- done:
        mutex_unlock(&irq_mapping_update_lock);
 }
@@ -1115,69 +1038,6 @@ void unbind_from_irqhandler(unsigned int irq, void *dev_id)
 }
 EXPORT_SYMBOL_GPL(unbind_from_irqhandler);
-int evtchn_make_refcounted(unsigned int evtchn)
-{
-        int irq = evtchn_to_irq[evtchn];
-        struct irq_info *info;
-        if (irq == -1)
-                return -ENOENT;
-        info = irq_get_handler_data(irq);
-        if (!info)
-                return -ENOENT;
-        WARN_ON(info->refcnt != -1);
-        info->refcnt = 1;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(evtchn_make_refcounted);
-int evtchn_get(unsigned int evtchn)
-{
-        int irq;
-        struct irq_info *info;
-        int err = -ENOENT;
-        if (evtchn >= NR_EVENT_CHANNELS)
-                return -EINVAL;
-        mutex_lock(&irq_mapping_update_lock);
-        irq = evtchn_to_irq[evtchn];
-        if (irq == -1)
-                goto done;
-        info = irq_get_handler_data(irq);
-        if (!info)
-                goto done;
-        err = -EINVAL;
-        if (info->refcnt <= 0)
-                goto done;
-        info->refcnt++;
-        err = 0;
- done:
-        mutex_unlock(&irq_mapping_update_lock);
-        return err;
-}
-EXPORT_SYMBOL_GPL(evtchn_get);
-void evtchn_put(unsigned int evtchn)
-{
-        int irq = evtchn_to_irq[evtchn];
-        if (WARN_ON(irq == -1))
-                return;
-        unbind_from_irq(irq);
-}
-EXPORT_SYMBOL_GPL(evtchn_put);
 void xen_send_IPI_one(unsigned int cpu, enum ipi_vector vector)
 {
        int irq = per_cpu(ipi_to_irq, cpu)[vector];
@@ -1292,7 +1152,7 @@ static void __xen_evtchn_do_upcall(void)
        int cpu = get_cpu();
        struct shared_info *s = HYPERVISOR_shared_info;
        struct vcpu_info *vcpu_info = __this_cpu_read(xen_vcpu);
-        unsigned count;
+        unsigned count;
        do {
                unsigned long pending_words;
@@ -1395,10 +1255,8 @@ void xen_evtchn_do_upcall(struct pt_regs *regs)
 {
        struct pt_regs *old_regs = set_irq_regs(regs);
-        irq_enter();
-#ifdef CONFIG_X86
        exit_idle();
-#endif
+        irq_enter();
        __xen_evtchn_do_upcall();
@@ -1812,7 +1670,6 @@ void __init xen_init_IRQ(void)
        evtchn_to_irq = kcalloc(NR_EVENT_CHANNELS, sizeof(*evtchn_to_irq),
                                    GFP_KERNEL);
-        BUG_ON(!evtchn_to_irq);
        for (i = 0; i < NR_EVENT_CHANNELS; i++)
                evtchn_to_irq[i] = -1;
@@ -1822,9 +1679,6 @@ void __init xen_init_IRQ(void)
        for (i = 0; i < NR_EVENT_CHANNELS; i++)
                mask_evtchn(i);
-        pirq_needs_eoi = pirq_needs_eoi_flag;
-#ifdef CONFIG_X86
        if (xen_hvm_domain()) {
                xen_callback_vector();
                native_init_IRQ();
@@ -1832,21 +1686,8 @@ void __init xen_init_IRQ(void)
                 * __acpi_register_gsi can point at the right function */
                pci_xen_hvm_init();
        } else {
-                int rc;
-                struct physdev_pirq_eoi_gmfn eoi_gmfn;
                irq_ctx_init(smp_processor_id());
                if (xen_initial_domain())
                        pci_xen_initial_domain();
-                pirq_eoi_map = (void *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
-                eoi_gmfn.gmfn = virt_to_mfn(pirq_eoi_map);
-                rc = HYPERVISOR_physdev_op(PHYSDEVOP_pirq_eoi_gmfn_v2, &eoi_gmfn);
-                if (rc != 0) {
-                        free_page((unsigned long) pirq_eoi_map);
-                        pirq_eoi_map = NULL;
-                } else
-                        pirq_needs_eoi = pirq_check_eoi_map;
        }
-#endif
 }
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index b1f60a0c0be..dbc13e94b61 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -268,7 +268,7 @@ static int evtchn_bind_to_user(struct per_user_data *u, int port)
        rc = bind_evtchn_to_irqhandler(port, evtchn_interrupt, IRQF_DISABLED,
                                       u->name, (void *)(unsigned long)port);
        if (rc >= 0)
-                rc = evtchn_make_refcounted(port);
+                rc = 0;
        return rc;
 }
diff --git a/drivers/xen/fallback.c b/drivers/xen/fallback.c
deleted file mode 100644
index 0ef7c4d40f8..00000000000
--- a/drivers/xen/fallback.c
+++ /dev/null
@@ -1,80 +0,0 @@
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/bug.h>
-#include <linux/export.h>
-#include <asm/hypervisor.h>
-#include <asm/xen/hypercall.h>
-int xen_event_channel_op_compat(int cmd, void *arg)
-{
-        struct evtchn_op op;
-        int rc;
-        op.cmd = cmd;
-        memcpy(&op.u, arg, sizeof(op.u));
-        rc = _hypercall1(int, event_channel_op_compat, &op);
-        switch (cmd) {
-        case EVTCHNOP_close:
-        case EVTCHNOP_send:
-        case EVTCHNOP_bind_vcpu:
-        case EVTCHNOP_unmask:
-                /* no output */
-                break;
-#define COPY_BACK(eop) \
-        case EVTCHNOP_##eop: \
-                memcpy(arg, &op.u.eop, sizeof(op.u.eop)); \
-                break
-        COPY_BACK(bind_interdomain);
-        COPY_BACK(bind_virq);
-        COPY_BACK(bind_pirq);
-        COPY_BACK(status);
-        COPY_BACK(alloc_unbound);
-        COPY_BACK(bind_ipi);
-#undef COPY_BACK
-        default:
-                WARN_ON(rc != -ENOSYS);
-                break;
-        }
-        return rc;
-}
-EXPORT_SYMBOL_GPL(xen_event_channel_op_compat);
-int HYPERVISOR_physdev_op_compat(int cmd, void *arg)
-{
-        struct physdev_op op;
-        int rc;
-        op.cmd = cmd;
-        memcpy(&op.u, arg, sizeof(op.u));
-        rc = _hypercall1(int, physdev_op_compat, &op);
-        switch (cmd) {
-        case PHYSDEVOP_IRQ_UNMASK_NOTIFY:
-        case PHYSDEVOP_set_iopl:
-        case PHYSDEVOP_set_iobitmap:
-        case PHYSDEVOP_apic_write:
-                /* no output */
-                break;
-#define COPY_BACK(pop, fld) \
-        case PHYSDEVOP_##pop: \
-                memcpy(arg, &op.u.fld, sizeof(op.u.fld)); \
-                break
-        COPY_BACK(irq_status_query, irq_status_query);
-        COPY_BACK(apic_read, apic_op);
-        COPY_BACK(ASSIGN_VECTOR, irq_op);
-#undef COPY_BACK
-        default:
-                WARN_ON(rc != -ENOSYS);
-                break;
-        }
-        return rc;
-}
diff --git a/drivers/xen/gntalloc.c b/drivers/xen/gntalloc.c
index 4097987b330..e1c4c6e5b46 100644
--- a/drivers/xen/gntalloc.c
+++ b/drivers/xen/gntalloc.c
@@ -74,7 +74,7 @@ MODULE_PARM_DESC(limit, "Maximum number of grants that may be allocated by "
                "the gntalloc device");
 static LIST_HEAD(gref_list);
-static DEFINE_MUTEX(gref_mutex);
+static DEFINE_SPINLOCK(gref_lock);
 static int gref_size;
 struct notify_info {
@@ -99,12 +99,6 @@ struct gntalloc_file_private_data {
        uint64_t index;
 };
-struct gntalloc_vma_private_data {
-        struct gntalloc_gref *gref;
-        int users;
-        int count;
-};
 static void __del_gref(struct gntalloc_gref *gref);
 static void do_cleanup(void)
@@ -149,15 +143,15 @@ static int add_grefs(struct ioctl_gntalloc_alloc_gref *op,
        }
        /* Add to gref lists. */
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        list_splice_tail(&queue_gref, &gref_list);
        list_splice_tail(&queue_file, &priv->list);
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        return 0;
 undo:
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        gref_size -= (op->count - i);
        list_for_each_entry(gref, &queue_file, next_file) {
@@ -173,7 +167,7 @@ undo:
         */
        if (unlikely(!list_empty(&queue_gref)))
                list_splice_tail(&queue_gref, &gref_list);
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        return rc;
 }
@@ -184,10 +178,8 @@ static void __del_gref(struct gntalloc_gref *gref)
                tmp[gref->notify.pgoff] = 0;
                kunmap(gref->page);
        }
-        if (gref->notify.flags & UNMAP_NOTIFY_SEND_EVENT) {
+        if (gref->notify.flags & UNMAP_NOTIFY_SEND_EVENT)
                notify_remote_via_evtchn(gref->notify.event);
-                evtchn_put(gref->notify.event);
-        }
        gref->notify.flags = 0;
@@ -197,8 +189,6 @@ static void __del_gref(struct gntalloc_gref *gref)
                if (!gnttab_end_foreign_access_ref(gref->gref_id, 0))
                        return;
-                gnttab_free_grant_reference(gref->gref_id);
        }
        gref_size--;
@@ -261,7 +251,7 @@ static int gntalloc_release(struct inode *inode, struct file *filp)
        pr_debug("%s: priv %p\n", __func__, priv);
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        while (!list_empty(&priv->list)) {
                gref = list_entry(priv->list.next,
                        struct gntalloc_gref, next_file);
@@ -271,7 +261,7 @@ static int gntalloc_release(struct inode *inode, struct file *filp)
                        __del_gref(gref);
        }
        kfree(priv);
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        return 0;
 }
@@ -296,21 +286,21 @@ static long gntalloc_ioctl_alloc(struct gntalloc_file_private_data *priv,
                goto out;
        }
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        /* Clean up pages that were at zero (local) users but were still mapped
         * by remote domains. Since those pages count towards the limit that we
         * are about to enforce, removing them here is a good idea.
         */
        do_cleanup();
        if (gref_size + op.count > limit) {
-                mutex_unlock(&gref_mutex);
+                spin_unlock(&gref_lock);
                rc = -ENOSPC;
                goto out_free;
        }
        gref_size += op.count;
        op.index = priv->index;
        priv->index += op.count * PAGE_SIZE;
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        rc = add_grefs(&op, gref_ids, priv);
        if (rc < 0)
@@ -353,7 +343,7 @@ static long gntalloc_ioctl_dealloc(struct gntalloc_file_private_data *priv,
                goto dealloc_grant_out;
        }
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        gref = find_grefs(priv, op.index, op.count);
        if (gref) {
                /* Remove from the file list only, and decrease reference count.
@@ -373,7 +363,7 @@ static long gntalloc_ioctl_dealloc(struct gntalloc_file_private_data *priv,
        do_cleanup();
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
 dealloc_grant_out:
        return rc;
 }
@@ -393,7 +383,7 @@ static long gntalloc_ioctl_unmap_notify(struct gntalloc_file_private_data *priv,
        index = op.index & ~(PAGE_SIZE - 1);
        pgoff = op.index & (PAGE_SIZE - 1);
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
        gref = find_grefs(priv, index, 1);
        if (!gref) {
@@ -406,30 +396,12 @@ static long gntalloc_ioctl_unmap_notify(struct gntalloc_file_private_data *priv,
                goto unlock_out;
        }
-        /* We need to grab a reference to the event channel we are going to use
-         * to send the notify before releasing the reference we may already have
-         * (if someone has called this ioctl twice). This is required so that
-         * it is possible to change the clear_byte part of the notification
-         * without disturbing the event channel part, which may now be the last
-         * reference to that event channel.
-         */
-        if (op.action & UNMAP_NOTIFY_SEND_EVENT) {
-                if (evtchn_get(op.event_channel_port)) {
-                        rc = -EINVAL;
-                        goto unlock_out;
-                }
-        }
-        if (gref->notify.flags & UNMAP_NOTIFY_SEND_EVENT)
-                evtchn_put(gref->notify.event);
        gref->notify.flags = op.action;
        gref->notify.pgoff = pgoff;
        gref->notify.event = op.event_channel_port;
        rc = 0;
 unlock_out:
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        return rc;
 }
@@ -457,40 +429,26 @@ static long gntalloc_ioctl(struct file *filp, unsigned int cmd,
 static void gntalloc_vma_open(struct vm_area_struct *vma)
 {
-        struct gntalloc_vma_private_data *priv = vma->vm_private_data;
+        struct gntalloc_gref *gref = vma->vm_private_data;
+        if (!gref)
-        if (!priv)
                return;
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
-        priv->users++;
+        gref->users++;
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
 }
 static void gntalloc_vma_close(struct vm_area_struct *vma)
 {
-        struct gntalloc_vma_private_data *priv = vma->vm_private_data;
+        struct gntalloc_gref *gref = vma->vm_private_data;
-        struct gntalloc_gref *gref, *next;
+        if (!gref)
-        int i;
-        if (!priv)
                return;
-        mutex_lock(&gref_mutex);
+        spin_lock(&gref_lock);
-        priv->users--;
+        gref->users--;
-        if (priv->users == 0) {
+        if (gref->users == 0)
-                gref = priv->gref;
+                __del_gref(gref);
-                for (i = 0; i < priv->count; i++) {
+        spin_unlock(&gref_lock);
-                        gref->users--;
-                        next = list_entry(gref->next_gref.next,
-                                          struct gntalloc_gref, next_gref);
-                        if (gref->users == 0)
-                                __del_gref(gref);
-                        gref = next;
-                }
-                kfree(priv);
-        }
-        mutex_unlock(&gref_mutex);
 }
 static struct vm_operations_struct gntalloc_vmops = {
@@ -501,41 +459,30 @@ static struct vm_operations_struct gntalloc_vmops = {
 static int gntalloc_mmap(struct file *filp, struct vm_area_struct *vma)
 {
        struct gntalloc_file_private_data *priv = filp->private_data;
-        struct gntalloc_vma_private_data *vm_priv;
        struct gntalloc_gref *gref;
        int count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
        int rv, i;
+        pr_debug("%s: priv %p, page %lu+%d\n", __func__,
+                       priv, vma->vm_pgoff, count);
        if (!(vma->vm_flags & VM_SHARED)) {
                printk(KERN_ERR "%s: Mapping must be shared.\n", __func__);
                return -EINVAL;
        }
-        vm_priv = kmalloc(sizeof(*vm_priv), GFP_KERNEL);
+        spin_lock(&gref_lock);
-        if (!vm_priv)
-                return -ENOMEM;
-        mutex_lock(&gref_mutex);
-        pr_debug("%s: priv %p,%p, page %lu+%d\n", __func__,
-                       priv, vm_priv, vma->vm_pgoff, count);
        gref = find_grefs(priv, vma->vm_pgoff << PAGE_SHIFT, count);
        if (gref == NULL) {
                rv = -ENOENT;
                pr_debug("%s: Could not find grant reference",
                                __func__);
-                kfree(vm_priv);
                goto out_unlock;
        }
-        vm_priv->gref = gref;
+        vma->vm_private_data = gref;
-        vm_priv->users = 1;
-        vm_priv->count = count;
-        vma->vm_private_data = vm_priv;
-        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= VM_RESERVED;
        vma->vm_ops = &gntalloc_vmops;
@@ -552,7 +499,7 @@ static int gntalloc_mmap(struct file *filp, struct vm_area_struct *vma)
        rv = 0;
 out_unlock:
-        mutex_unlock(&gref_mutex);
+        spin_unlock(&gref_lock);
        return rv;
 }
diff --git a/drivers/xen/gntdev.c b/drivers/xen/gntdev.c
index 2e22df2f7a3..f914b26cf0c 100644
--- a/drivers/xen/gntdev.c
+++ b/drivers/xen/gntdev.c
@@ -83,7 +83,6 @@ struct grant_map {
        struct ioctl_gntdev_grant_ref *grants;
        struct gnttab_map_grant_ref   *map_ops;
        struct gnttab_unmap_grant_ref *unmap_ops;
-        struct gnttab_map_grant_ref   *kmap_ops;
        struct page **pages;
 };
@@ -105,21 +104,6 @@ static void gntdev_print_maps(struct gntdev_priv *priv,
 #endif
 }
-static void gntdev_free_map(struct grant_map *map)
-{
-        if (map == NULL)
-                return;
-        if (map->pages)
-                free_xenballooned_pages(map->count, map->pages);
-        kfree(map->pages);
-        kfree(map->grants);
-        kfree(map->map_ops);
-        kfree(map->unmap_ops);
-        kfree(map->kmap_ops);
-        kfree(map);
-}
 static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count)
 {
        struct grant_map *add;
@@ -129,25 +113,22 @@ static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count)
        if (NULL == add)
                return NULL;
-        add->grants    = kcalloc(count, sizeof(add->grants[0]), GFP_KERNEL);
+        add->grants    = kzalloc(sizeof(add->grants[0])    * count, GFP_KERNEL);
-        add->map_ops   = kcalloc(count, sizeof(add->map_ops[0]), GFP_KERNEL);
+        add->map_ops   = kzalloc(sizeof(add->map_ops[0])   * count, GFP_KERNEL);
-        add->unmap_ops = kcalloc(count, sizeof(add->unmap_ops[0]), GFP_KERNEL);
+        add->unmap_ops = kzalloc(sizeof(add->unmap_ops[0]) * count, GFP_KERNEL);
-        add->kmap_ops  = kcalloc(count, sizeof(add->kmap_ops[0]), GFP_KERNEL);
+        add->pages     = kzalloc(sizeof(add->pages[0])     * count, GFP_KERNEL);
-        add->pages     = kcalloc(count, sizeof(add->pages[0]), GFP_KERNEL);
        if (NULL == add->grants    ||
            NULL == add->map_ops   ||
            NULL == add->unmap_ops ||
-            NULL == add->kmap_ops  ||
            NULL == add->pages)
                goto err;
-        if (alloc_xenballooned_pages(count, add->pages, false /* lowmem */))
+        if (alloc_xenballooned_pages(count, add->pages))
                goto err;
        for (i = 0; i < count; i++) {
                add->map_ops[i].handle = -1;
                add->unmap_ops[i].handle = -1;
-                add->kmap_ops[i].handle = -1;
        }
        add->index = 0;
@@ -157,7 +138,11 @@ static struct grant_map *gntdev_alloc_map(struct gntdev_priv *priv, int count)
        return add;
 err:
-        gntdev_free_map(add);
+        kfree(add->pages);
+        kfree(add->grants);
+        kfree(add->map_ops);
+        kfree(add->unmap_ops);
+        kfree(add);
        return NULL;
 }
@@ -205,12 +190,19 @@ static void gntdev_put_map(struct grant_map *map)
        if (map->notify.flags & UNMAP_NOTIFY_SEND_EVENT) {
                notify_remote_via_evtchn(map->notify.event);
-                evtchn_put(map->notify.event);
        }
-        if (map->pages && !use_ptemod)
+        if (map->pages) {
-                unmap_grant_pages(map, 0, map->count);
+                if (!use_ptemod)
-        gntdev_free_map(map);
+                        unmap_grant_pages(map, 0, map->count);
+                free_xenballooned_pages(map->count, map->pages);
+        }
+        kfree(map->pages);
+        kfree(map->grants);
+        kfree(map->map_ops);
+        kfree(map->unmap_ops);
+        kfree(map);
 }
 /* ------------------------------------------------------------------ */
@@ -251,35 +243,10 @@ static int map_grant_pages(struct grant_map *map)
                        gnttab_set_unmap_op(&map->unmap_ops[i], addr,
                                map->flags, -1 /* handle */);
                }
-        } else {
-                /*
-                 * Setup the map_ops corresponding to the pte entries pointing
-                 * to the kernel linear addresses of the struct pages.
-                 * These ptes are completely different from the user ptes dealt
-                 * with find_grant_ptes.
-                 */
-                for (i = 0; i < map->count; i++) {
-                        unsigned level;
-                        unsigned long address = (unsigned long)
-                                pfn_to_kaddr(page_to_pfn(map->pages[i]));
-                        pte_t *ptep;
-                        u64 pte_maddr = 0;
-                        BUG_ON(PageHighMem(map->pages[i]));
-                        ptep = lookup_address(address, &level);
-                        pte_maddr = arbitrary_virt_to_machine(ptep).maddr;
-                        gnttab_set_map_op(&map->kmap_ops[i], pte_maddr,
-                                map->flags |
-                                GNTMAP_host_map |
-                                GNTMAP_contains_pte,
-                                map->grants[i].ref,
-                                map->grants[i].domid);
-                }
        }
        pr_debug("map %d+%d\n", map->index, map->count);
-        err = gnttab_map_refs(map->map_ops, use_ptemod ? map->kmap_ops : NULL,
+        err = gnttab_map_refs(map->map_ops, map->pages, map->count);
-                        map->pages, map->count);
        if (err)
                return err;
@@ -316,9 +283,7 @@ static int __unmap_grant_pages(struct grant_map *map, int offset, int pages)
                }
        }
-        err = gnttab_unmap_refs(map->unmap_ops + offset,
+        err = gnttab_unmap_refs(map->unmap_ops + offset, map->pages + offset, pages);
-                        use_ptemod ? map->kmap_ops + offset : NULL, map->pages + offset,
-                        pages);
        if (err)
                return err;
@@ -448,7 +413,7 @@ static void mn_release(struct mmu_notifier *mn,
        spin_unlock(&priv->lock);
 }
-static struct mmu_notifier_ops gntdev_mmu_ops = {
+struct mmu_notifier_ops gntdev_mmu_ops = {
        .release                = mn_release,
        .invalidate_page        = mn_invl_page,
        .invalidate_range_start = mn_invl_range_start,
@@ -497,11 +462,13 @@ static int gntdev_release(struct inode *inode, struct file *flip)
        pr_debug("priv %p\n", priv);
+        spin_lock(&priv->lock);
        while (!list_empty(&priv->maps)) {
                map = list_entry(priv->maps.next, struct grant_map, next);
                list_del(&map->next);
                gntdev_put_map(map);
        }
+        spin_unlock(&priv->lock);
        if (use_ptemod)
                mmu_notifier_unregister(&priv->mn, priv->mm);
@@ -565,11 +532,10 @@ static long gntdev_ioctl_unmap_grant_ref(struct gntdev_priv *priv,
        map = gntdev_find_map_index(priv, op.index >> PAGE_SHIFT, op.count);
        if (map) {
                list_del(&map->next);
+                gntdev_put_map(map);
                err = 0;
        }
        spin_unlock(&priv->lock);
-        if (map)
-                gntdev_put_map(map);
        return err;
 }
@@ -605,8 +571,6 @@ static long gntdev_ioctl_notify(struct gntdev_priv *priv, void __user *u)
        struct ioctl_gntdev_unmap_notify op;
        struct grant_map *map;
        int rc;
-        int out_flags;
-        unsigned int out_event;
        if (copy_from_user(&op, u, sizeof(op)))
                return -EFAULT;
@@ -614,21 +578,6 @@ static long gntdev_ioctl_notify(struct gntdev_priv *priv, void __user *u)
        if (op.action & ~(UNMAP_NOTIFY_CLEAR_BYTE|UNMAP_NOTIFY_SEND_EVENT))
                return -EINVAL;
-        /* We need to grab a reference to the event channel we are going to use
-         * to send the notify before releasing the reference we may already have
-         * (if someone has called this ioctl twice). This is required so that
-         * it is possible to change the clear_byte part of the notification
-         * without disturbing the event channel part, which may now be the last
-         * reference to that event channel.
-         */
-        if (op.action & UNMAP_NOTIFY_SEND_EVENT) {
-                if (evtchn_get(op.event_channel_port))
-                        return -EINVAL;
-        }
-        out_flags = op.action;
-        out_event = op.event_channel_port;
        spin_lock(&priv->lock);
        list_for_each_entry(map, &priv->maps, next) {
@@ -647,22 +596,12 @@ static long gntdev_ioctl_notify(struct gntdev_priv *priv, void __user *u)
                goto unlock_out;
        }
-        out_flags = map->notify.flags;
-        out_event = map->notify.event;
        map->notify.flags = op.action;
        map->notify.addr = op.index - (map->index << PAGE_SHIFT);
        map->notify.event = op.event_channel_port;
        rc = 0;
 unlock_out:
        spin_unlock(&priv->lock);
-        /* Drop the reference to the event channel we did not save in the map */
-        if (out_flags & UNMAP_NOTIFY_SEND_EVENT)
-                evtchn_put(out_event);
        return rc;
 }
@@ -722,10 +661,10 @@ static int gntdev_mmap(struct file *flip, struct vm_area_struct *vma)
        vma->vm_ops = &gntdev_vmops;
-        vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+        vma->vm_flags |= VM_RESERVED|VM_DONTEXPAND;
        if (use_ptemod)
-                vma->vm_flags |= VM_DONTCOPY;
+                vma->vm_flags |= VM_DONTCOPY|VM_PFNMAP;
        vma->vm_private_data = map;
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index 7038de53652..4f44b347b24 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -38,28 +38,22 @@
 #include <linux/vmalloc.h>
 #include <linux/uaccess.h>
 #include <linux/io.h>
-#include <linux/delay.h>
-#include <linux/hardirq.h>
 #include <xen/xen.h>
 #include <xen/interface/xen.h>
 #include <xen/page.h>
 #include <xen/grant_table.h>
 #include <xen/interface/memory.h>
-#include <xen/hvc-console.h>
 #include <asm/xen/hypercall.h>
-#include <asm/xen/interface.h>
 #include <asm/pgtable.h>
 #include <asm/sync_bitops.h>
 /* External tools reserve first few grant table entries. */
 #define NR_RESERVED_ENTRIES 8
 #define GNTTAB_LIST_END 0xffffffff
-#define GREFS_PER_GRANT_FRAME \
+#define GREFS_PER_GRANT_FRAME (PAGE_SIZE / sizeof(struct grant_entry))
-(grant_table_version == 1 ?                      \
-(PAGE_SIZE / sizeof(struct grant_entry_v1)) :   \
-(PAGE_SIZE / sizeof(union grant_entry_v2)))
 static grant_ref_t **gnttab_list;
 static unsigned int nr_grant_frames;
@@ -70,97 +64,13 @@ static DEFINE_SPINLOCK(gnttab_list_lock);
 unsigned long xen_hvm_resume_frames;
 EXPORT_SYMBOL_GPL(xen_hvm_resume_frames);
-static union {
+static struct grant_entry *shared;
-        struct grant_entry_v1 *v1;
-        union grant_entry_v2 *v2;
-        void *addr;
-} gnttab_shared;
-/*This is a structure of function pointers for grant table*/
-struct gnttab_ops {
-        /*
-         * Mapping a list of frames for storing grant entries. Frames parameter
-         * is used to store grant table address when grant table being setup,
-         * nr_gframes is the number of frames to map grant table. Returning
-         * GNTST_okay means success and negative value means failure.
-         */
-        int (*map_frames)(xen_pfn_t *frames, unsigned int nr_gframes);
-        /*
-         * Release a list of frames which are mapped in map_frames for grant
-         * entry status.
-         */
-        void (*unmap_frames)(void);
-        /*
-         * Introducing a valid entry into the grant table, granting the frame of
-         * this grant entry to domain for accessing or transfering. Ref
-         * parameter is reference of this introduced grant entry, domid is id of
-         * granted domain, frame is the page frame to be granted, and flags is
-         * status of the grant entry to be updated.
-         */
-        void (*update_entry)(grant_ref_t ref, domid_t domid,
-                             unsigned long frame, unsigned flags);
-        /*
-         * Stop granting a grant entry to domain for accessing. Ref parameter is
-         * reference of a grant entry whose grant access will be stopped,
-         * readonly is not in use in this function. If the grant entry is
-         * currently mapped for reading or writing, just return failure(==0)
-         * directly and don't tear down the grant access. Otherwise, stop grant
-         * access for this entry and return success(==1).
-         */
-        int (*end_foreign_access_ref)(grant_ref_t ref, int readonly);
-        /*
-         * Stop granting a grant entry to domain for transfer. Ref parameter is
-         * reference of a grant entry whose grant transfer will be stopped. If
-         * tranfer has not started, just reclaim the grant entry and return
-         * failure(==0). Otherwise, wait for the transfer to complete and then
-         * return the frame.
-         */
-        unsigned long (*end_foreign_transfer_ref)(grant_ref_t ref);
-        /*
-         * Query the status of a grant entry. Ref parameter is reference of
-         * queried grant entry, return value is the status of queried entry.
-         * Detailed status(writing/reading) can be gotten from the return value
-         * by bit operations.
-         */
-        int (*query_foreign_access)(grant_ref_t ref);
-        /*
-         * Grant a domain to access a range of bytes within the page referred by
-         * an available grant entry. Ref parameter is reference of a grant entry
-         * which will be sub-page accessed, domid is id of grantee domain, frame
-         * is frame address of subpage grant, flags is grant type and flag
-         * information, page_off is offset of the range of bytes, and length is
-         * length of bytes to be accessed.
-         */
-        void (*update_subpage_entry)(grant_ref_t ref, domid_t domid,
-                                     unsigned long frame, int flags,
-                                     unsigned page_off, unsigned length);
-        /*
-         * Redirect an available grant entry on domain A to another grant
-         * reference of domain B, then allow domain C to use grant reference
-         * of domain B transitively. Ref parameter is an available grant entry
-         * reference on domain A, domid is id of domain C which accesses grant
-         * entry transitively, flags is grant type and flag information,
-         * trans_domid is id of domain B whose grant entry is finally accessed
-         * transitively, trans_gref is grant entry transitive reference of
-         * domain B.
-         */
-        void (*update_trans_entry)(grant_ref_t ref, domid_t domid, int flags,
-                                   domid_t trans_domid, grant_ref_t trans_gref);
-};
-static struct gnttab_ops *gnttab_interface;
-/*This reflects status of grant entries, so act as a global value*/
-static grant_status_t *grstatus;
-static int grant_table_version;
 static struct gnttab_free_callback *gnttab_free_callback_list;
 static int gnttab_expand(unsigned int req_entries);
 #define RPP (PAGE_SIZE / sizeof(grant_ref_t))
-#define SPP (PAGE_SIZE / sizeof(grant_status_t))
 static inline grant_ref_t *__gnttab_entry(grant_ref_t entry)
 {
@@ -232,33 +142,23 @@ static void put_free_entry(grant_ref_t ref)
        spin_unlock_irqrestore(&gnttab_list_lock, flags);
 }
-/*
+static void update_grant_entry(grant_ref_t ref, domid_t domid,
- * Following applies to gnttab_update_entry_v1 and gnttab_update_entry_v2.
+                               unsigned long frame, unsigned flags)
- * Introducing a valid entry into the grant table:
- *  1. Write ent->domid.
- *  2. Write ent->frame:
- *      GTF_permit_access:   Frame to which access is permitted.
- *      GTF_accept_transfer: Pseudo-phys frame slot being filled by new
- *                           frame, or zero if none.
- *  3. Write memory barrier (WMB).
- *  4. Write ent->flags, inc. valid type.
- */
-static void gnttab_update_entry_v1(grant_ref_t ref, domid_t domid,
-                                   unsigned long frame, unsigned flags)
 {
-        gnttab_shared.v1[ref].domid = domid;
+        /*
-        gnttab_shared.v1[ref].frame = frame;
+         * Introducing a valid entry into the grant table:
-        wmb();
+         *  1. Write ent->domid.
-        gnttab_shared.v1[ref].flags = flags;
+         *  2. Write ent->frame:
-}
+         *      GTF_permit_access:   Frame to which access is permitted.
+         *      GTF_accept_transfer: Pseudo-phys frame slot being filled by new
-static void gnttab_update_entry_v2(grant_ref_t ref, domid_t domid,
+         *                           frame, or zero if none.
-                                   unsigned long frame, unsigned flags)
+         *  3. Write memory barrier (WMB).
-{
+         *  4. Write ent->flags, inc. valid type.
-        gnttab_shared.v2[ref].hdr.domid = domid;
+         */
-        gnttab_shared.v2[ref].full_page.frame = frame;
+        shared[ref].frame = frame;
+        shared[ref].domid = domid;
        wmb();
-        gnttab_shared.v2[ref].hdr.flags = GTF_permit_access | flags;
+        shared[ref].flags = flags;
 }
 /*
@@ -267,7 +167,7 @@ static void gnttab_update_entry_v2(grant_ref_t ref, domid_t domid,
 void gnttab_grant_foreign_access_ref(grant_ref_t ref, domid_t domid,
                                     unsigned long frame, int readonly)
 {
-        gnttab_interface->update_entry(ref, domid, frame,
+        update_grant_entry(ref, domid, frame,
                           GTF_permit_access | (readonly ? GTF_readonly : 0));
 }
 EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_ref);
@@ -287,274 +187,33 @@ int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
 }
 EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access);
-static void gnttab_update_subpage_entry_v2(grant_ref_t ref, domid_t domid,
+int gnttab_query_foreign_access(grant_ref_t ref)
-                                           unsigned long frame, int flags,
-                                           unsigned page_off, unsigned length)
-{
-        gnttab_shared.v2[ref].sub_page.frame = frame;
-        gnttab_shared.v2[ref].sub_page.page_off = page_off;
-        gnttab_shared.v2[ref].sub_page.length = length;
-        gnttab_shared.v2[ref].hdr.domid = domid;
-        wmb();
-        gnttab_shared.v2[ref].hdr.flags =
-                                GTF_permit_access | GTF_sub_page | flags;
-}
-int gnttab_grant_foreign_access_subpage_ref(grant_ref_t ref, domid_t domid,
-                                            unsigned long frame, int flags,
-                                            unsigned page_off,
-                                            unsigned length)
-{
-        if (flags & (GTF_accept_transfer | GTF_reading |
-                     GTF_writing | GTF_transitive))
-                return -EPERM;
-        if (gnttab_interface->update_subpage_entry == NULL)
-                return -ENOSYS;
-        gnttab_interface->update_subpage_entry(ref, domid, frame, flags,
-                                               page_off, length);
-        return 0;
-}
-EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_subpage_ref);
-int gnttab_grant_foreign_access_subpage(domid_t domid, unsigned long frame,
-                                        int flags, unsigned page_off,
-                                        unsigned length)
-{
-        int ref, rc;
-        ref = get_free_entries(1);
-        if (unlikely(ref < 0))
-                return -ENOSPC;
-        rc = gnttab_grant_foreign_access_subpage_ref(ref, domid, frame, flags,
-                                                     page_off, length);
-        if (rc < 0) {
-                put_free_entry(ref);
-                return rc;
-        }
-        return ref;
-}
-EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_subpage);
-bool gnttab_subpage_grants_available(void)
-{
-        return gnttab_interface->update_subpage_entry != NULL;
-}
-EXPORT_SYMBOL_GPL(gnttab_subpage_grants_available);
-static void gnttab_update_trans_entry_v2(grant_ref_t ref, domid_t domid,
-                                         int flags, domid_t trans_domid,
-                                         grant_ref_t trans_gref)
-{
-        gnttab_shared.v2[ref].transitive.trans_domid = trans_domid;
-        gnttab_shared.v2[ref].transitive.gref = trans_gref;
-        gnttab_shared.v2[ref].hdr.domid = domid;
-        wmb();
-        gnttab_shared.v2[ref].hdr.flags =
-                                GTF_permit_access | GTF_transitive | flags;
-}
-int gnttab_grant_foreign_access_trans_ref(grant_ref_t ref, domid_t domid,
-                                          int flags, domid_t trans_domid,
-                                          grant_ref_t trans_gref)
-{
-        if (flags & (GTF_accept_transfer | GTF_reading |
-                     GTF_writing | GTF_sub_page))
-                return -EPERM;
-        if (gnttab_interface->update_trans_entry == NULL)
-                return -ENOSYS;
-        gnttab_interface->update_trans_entry(ref, domid, flags, trans_domid,
-                                             trans_gref);
-        return 0;
-}
-EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_trans_ref);
-int gnttab_grant_foreign_access_trans(domid_t domid, int flags,
-                                      domid_t trans_domid,
-                                      grant_ref_t trans_gref)
-{
-        int ref, rc;
-        ref = get_free_entries(1);
-        if (unlikely(ref < 0))
-                return -ENOSPC;
-        rc = gnttab_grant_foreign_access_trans_ref(ref, domid, flags,
-                                                   trans_domid, trans_gref);
-        if (rc < 0) {
-                put_free_entry(ref);
-                return rc;
-        }
-        return ref;
-}
-EXPORT_SYMBOL_GPL(gnttab_grant_foreign_access_trans);
-bool gnttab_trans_grants_available(void)
 {
-        return gnttab_interface->update_trans_entry != NULL;
+        u16 nflags;
-}
-EXPORT_SYMBOL_GPL(gnttab_trans_grants_available);
-static int gnttab_query_foreign_access_v1(grant_ref_t ref)
+        nflags = shared[ref].flags;
-{
-        return gnttab_shared.v1[ref].flags & (GTF_reading|GTF_writing);
-}
-static int gnttab_query_foreign_access_v2(grant_ref_t ref)
+        return (nflags & (GTF_reading|GTF_writing));
-{
-        return grstatus[ref] & (GTF_reading|GTF_writing);
-}
-int gnttab_query_foreign_access(grant_ref_t ref)
-{
-        return gnttab_interface->query_foreign_access(ref);
 }
 EXPORT_SYMBOL_GPL(gnttab_query_foreign_access);
-static int gnttab_end_foreign_access_ref_v1(grant_ref_t ref, int readonly)
+int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
 {
        u16 flags, nflags;
-        u16 *pflags;
-        pflags = &gnttab_shared.v1[ref].flags;
+        nflags = shared[ref].flags;
-        nflags = *pflags;
        do {
                flags = nflags;
-                if (flags & (GTF_reading|GTF_writing))
+                if (flags & (GTF_reading|GTF_writing)) {
+                        printk(KERN_ALERT "WARNING: g.e. still in use!\n");
                        return 0;
-        } while ((nflags = sync_cmpxchg(pflags, flags, 0)) != flags);
+                }
+        } while ((nflags = sync_cmpxchg(&shared[ref].flags, flags, 0)) != flags);
-        return 1;
-}
-static int gnttab_end_foreign_access_ref_v2(grant_ref_t ref, int readonly)
-{
-        gnttab_shared.v2[ref].hdr.flags = 0;
-        mb();
-        if (grstatus[ref] & (GTF_reading|GTF_writing)) {
-                return 0;
-        } else {
-                /* The read of grstatus needs to have acquire
-                semantics.  On x86, reads already have
-                that, and we just need to protect against
-                compiler reorderings.  On other
-                architectures we may need a full
-                barrier. */
-#ifdef CONFIG_X86
-                barrier();
-#else
-                mb();
-#endif
-        }
        return 1;
 }
-static inline int _gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
-{
-        return gnttab_interface->end_foreign_access_ref(ref, readonly);
-}
-int gnttab_end_foreign_access_ref(grant_ref_t ref, int readonly)
-{
-        if (_gnttab_end_foreign_access_ref(ref, readonly))
-                return 1;
-        pr_warn("WARNING: g.e. %#x still in use!\n", ref);
-        return 0;
-}
 EXPORT_SYMBOL_GPL(gnttab_end_foreign_access_ref);
-struct deferred_entry {
-        struct list_head list;
-        grant_ref_t ref;
-        bool ro;
-        uint16_t warn_delay;
-        struct page *page;
-};
-static LIST_HEAD(deferred_list);
-static void gnttab_handle_deferred(unsigned long);
-static DEFINE_TIMER(deferred_timer, gnttab_handle_deferred, 0, 0);
-static void gnttab_handle_deferred(unsigned long unused)
-{
-        unsigned int nr = 10;
-        struct deferred_entry *first = NULL;
-        unsigned long flags;
-        spin_lock_irqsave(&gnttab_list_lock, flags);
-        while (nr--) {
-                struct deferred_entry *entry
-                        = list_first_entry(&deferred_list,
-                                           struct deferred_entry, list);
-                if (entry == first)
-                        break;
-                list_del(&entry->list);
-                spin_unlock_irqrestore(&gnttab_list_lock, flags);
-                if (_gnttab_end_foreign_access_ref(entry->ref, entry->ro)) {
-                        put_free_entry(entry->ref);
-                        if (entry->page) {
-                                pr_debug("freeing g.e. %#x (pfn %#lx)\n",
-                                         entry->ref, page_to_pfn(entry->page));
-                                __free_page(entry->page);
-                        } else
-                                pr_info("freeing g.e. %#x\n", entry->ref);
-                        kfree(entry);
-                        entry = NULL;
-                } else {
-                        if (!--entry->warn_delay)
-                                pr_info("g.e. %#x still pending\n",
-                                        entry->ref);
-                        if (!first)
-                                first = entry;
-                }
-                spin_lock_irqsave(&gnttab_list_lock, flags);
-                if (entry)
-                        list_add_tail(&entry->list, &deferred_list);
-                else if (list_empty(&deferred_list))
-                        break;
-        }
-        if (!list_empty(&deferred_list) && !timer_pending(&deferred_timer)) {
-                deferred_timer.expires = jiffies + HZ;
-                add_timer(&deferred_timer);
-        }
-        spin_unlock_irqrestore(&gnttab_list_lock, flags);
-}
-static void gnttab_add_deferred(grant_ref_t ref, bool readonly,
-                                struct page *page)
-{
-        struct deferred_entry *entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
-        const char *what = KERN_WARNING "leaking";
-        if (entry) {
-                unsigned long flags;
-                entry->ref = ref;
-                entry->ro = readonly;
-                entry->page = page;
-                entry->warn_delay = 60;
-                spin_lock_irqsave(&gnttab_list_lock, flags);
-                list_add_tail(&entry->list, &deferred_list);
-                if (!timer_pending(&deferred_timer)) {
-                        deferred_timer.expires = jiffies + HZ;
-                        add_timer(&deferred_timer);
-                }
-                spin_unlock_irqrestore(&gnttab_list_lock, flags);
-                what = KERN_DEBUG "deferring";
-        }
-        printk("%s g.e. %#x (pfn %#lx)\n",
-               what, ref, page ? page_to_pfn(page) : -1);
-}
 void gnttab_end_foreign_access(grant_ref_t ref, int readonly,
                               unsigned long page)
 {
@@ -562,9 +221,12 @@ void gnttab_end_foreign_access(grant_ref_t ref, int readonly,
                put_free_entry(ref);
                if (page != 0)
                        free_page(page);
-        } else
+        } else {
-                gnttab_add_deferred(ref, readonly,
+                /* XXX This needs to be fixed so that the ref and page are
-                                    page ? virt_to_page(page) : NULL);
+                   placed on a list to be freed up later. */
+                printk(KERN_WARNING
+                       "WARNING: leaking g.e. and page still in use!\n");
+        }
 }
 EXPORT_SYMBOL_GPL(gnttab_end_foreign_access);
@@ -584,76 +246,37 @@ EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer);
 void gnttab_grant_foreign_transfer_ref(grant_ref_t ref, domid_t domid,
                                       unsigned long pfn)
 {
-        gnttab_interface->update_entry(ref, domid, pfn, GTF_accept_transfer);
+        update_grant_entry(ref, domid, pfn, GTF_accept_transfer);
 }
 EXPORT_SYMBOL_GPL(gnttab_grant_foreign_transfer_ref);
-static unsigned long gnttab_end_foreign_transfer_ref_v1(grant_ref_t ref)
+unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref)
 {
        unsigned long frame;
        u16           flags;
-        u16          *pflags;
-        pflags = &gnttab_shared.v1[ref].flags;
        /*
         * If a transfer is not even yet started, try to reclaim the grant
         * reference and return failure (== 0).
         */
-        while (!((flags = *pflags) & GTF_transfer_committed)) {
+        while (!((flags = shared[ref].flags) & GTF_transfer_committed)) {
-                if (sync_cmpxchg(pflags, flags, 0) == flags)
+                if (sync_cmpxchg(&shared[ref].flags, flags, 0) == flags)
                        return 0;
                cpu_relax();
        }
        /* If a transfer is in progress then wait until it is completed. */
        while (!(flags & GTF_transfer_completed)) {
-                flags = *pflags;
+                flags = shared[ref].flags;
                cpu_relax();
        }
        rmb();  /* Read the frame number /after/ reading completion status. */
-        frame = gnttab_shared.v1[ref].frame;
+        frame = shared[ref].frame;
        BUG_ON(frame == 0);
        return frame;
 }
-static unsigned long gnttab_end_foreign_transfer_ref_v2(grant_ref_t ref)
-{
-        unsigned long frame;
-        u16           flags;
-        u16          *pflags;
-        pflags = &gnttab_shared.v2[ref].hdr.flags;
-        /*
-         * If a transfer is not even yet started, try to reclaim the grant
-         * reference and return failure (== 0).
-         */
-        while (!((flags = *pflags) & GTF_transfer_committed)) {
-                if (sync_cmpxchg(pflags, flags, 0) == flags)
-                        return 0;
-                cpu_relax();
-        }
-        /* If a transfer is in progress then wait until it is completed. */
-        while (!(flags & GTF_transfer_completed)) {
-                flags = *pflags;
-                cpu_relax();
-        }
-        rmb();  /* Read the frame number /after/ reading completion status. */
-        frame = gnttab_shared.v2[ref].full_page.frame;
-        BUG_ON(frame == 0);
-        return frame;
-}
-unsigned long gnttab_end_foreign_transfer_ref(grant_ref_t ref)
-{
-        return gnttab_interface->end_foreign_transfer_ref(ref);
-}
 EXPORT_SYMBOL_GPL(gnttab_end_foreign_transfer_ref);
 unsigned long gnttab_end_foreign_transfer(grant_ref_t ref)
@@ -824,58 +447,10 @@ unsigned int gnttab_max_grant_frames(void)
 }
 EXPORT_SYMBOL_GPL(gnttab_max_grant_frames);
-/* Handling of paged out grant targets (GNTST_eagain) */
-#define MAX_DELAY 256
-static inline void
-gnttab_retry_eagain_gop(unsigned int cmd, void *gop, int16_t *status,
-                                                const char *func)
-{
-        unsigned delay = 1;
-        do {
-                BUG_ON(HYPERVISOR_grant_table_op(cmd, gop, 1));
-                if (*status == GNTST_eagain)
-                        msleep(delay++);
-        } while ((*status == GNTST_eagain) && (delay < MAX_DELAY));
-        if (delay >= MAX_DELAY) {
-                printk(KERN_ERR "%s: %s eagain grant\n", func, current->comm);
-                *status = GNTST_bad_page;
-        }
-}
-void gnttab_batch_map(struct gnttab_map_grant_ref *batch, unsigned count)
-{
-        struct gnttab_map_grant_ref *op;
-        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, batch, count))
-                BUG();
-        for (op = batch; op < batch + count; op++)
-                if (op->status == GNTST_eagain)
-                        gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, op,
-                                                &op->status, __func__);
-}
-EXPORT_SYMBOL_GPL(gnttab_batch_map);
-void gnttab_batch_copy(struct gnttab_copy *batch, unsigned count)
-{
-        struct gnttab_copy *op;
-        if (HYPERVISOR_grant_table_op(GNTTABOP_copy, batch, count))
-                BUG();
-        for (op = batch; op < batch + count; op++)
-                if (op->status == GNTST_eagain)
-                        gnttab_retry_eagain_gop(GNTTABOP_copy, op,
-                                                &op->status, __func__);
-}
-EXPORT_SYMBOL_GPL(gnttab_batch_copy);
 int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
-                    struct gnttab_map_grant_ref *kmap_ops,
                    struct page **pages, unsigned int count)
 {
        int i, ret;
-        bool lazy = false;
        pte_t *pte;
        unsigned long mfn;
@@ -883,20 +458,9 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
        if (ret)
                return ret;
-        /* Retry eagain maps */
-        for (i = 0; i < count; i++)
-                if (map_ops[i].status == GNTST_eagain)
-                        gnttab_retry_eagain_gop(GNTTABOP_map_grant_ref, map_ops + i,
-                                                &map_ops[i].status, __func__);
        if (xen_feature(XENFEAT_auto_translated_physmap))
                return ret;
-        if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {
-                arch_enter_lazy_mmu_mode();
-                lazy = true;
-        }
        for (i = 0; i < count; i++) {
                /* Do not add to override if the map failed. */
                if (map_ops[i].status)
@@ -907,27 +471,37 @@ int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
                                (map_ops[i].host_addr & ~PAGE_MASK));
                        mfn = pte_mfn(*pte);
                } else {
-                        mfn = PFN_DOWN(map_ops[i].dev_bus_addr);
+                        /* If you really wanted to do this:
+                         * mfn = PFN_DOWN(map_ops[i].dev_bus_addr);
+                         *
+                         * The reason we do not implement it is b/c on the
+                         * unmap path (gnttab_unmap_refs) we have no means of
+                         * checking whether the page is !GNTMAP_contains_pte.
+                         *
+                         * That is without some extra data-structure to carry
+                         * the struct page, bool clear_pte, and list_head next
+                         * tuples and deal with allocation/delallocation, etc.
+                         *
+                         * The users of this API set the GNTMAP_contains_pte
+                         * flag so lets just return not supported until it
+                         * becomes neccessary to implement.
+                         */
+                        return -EOPNOTSUPP;
                }
-                ret = m2p_add_override(mfn, pages[i], kmap_ops ?
+                ret = m2p_add_override(mfn, pages[i],
-                                       &kmap_ops[i] : NULL);
+                                       map_ops[i].flags & GNTMAP_contains_pte);
                if (ret)
                        return ret;
        }
-        if (lazy)
-                arch_leave_lazy_mmu_mode();
        return ret;
 }
 EXPORT_SYMBOL_GPL(gnttab_map_refs);
 int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
-                      struct gnttab_map_grant_ref *kmap_ops,
+                struct page **pages, unsigned int count)
-                      struct page **pages, unsigned int count)
 {
        int i, ret;
-        bool lazy = false;
        ret = HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap_ops, count);
        if (ret)
@@ -936,100 +510,20 @@ int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
        if (xen_feature(XENFEAT_auto_translated_physmap))
                return ret;
-        if (!in_interrupt() && paravirt_get_lazy_mode() == PARAVIRT_LAZY_NONE) {
-                arch_enter_lazy_mmu_mode();
-                lazy = true;
-        }
        for (i = 0; i < count; i++) {
-                ret = m2p_remove_override(pages[i], kmap_ops ?
+                ret = m2p_remove_override(pages[i], true /* clear the PTE */);
-                                       &kmap_ops[i] : NULL);
                if (ret)
                        return ret;
        }
-        if (lazy)
-                arch_leave_lazy_mmu_mode();
        return ret;
 }
 EXPORT_SYMBOL_GPL(gnttab_unmap_refs);
-static unsigned nr_status_frames(unsigned nr_grant_frames)
-{
-        return (nr_grant_frames * GREFS_PER_GRANT_FRAME + SPP - 1) / SPP;
-}
-static int gnttab_map_frames_v1(xen_pfn_t *frames, unsigned int nr_gframes)
-{
-        int rc;
-        rc = arch_gnttab_map_shared(frames, nr_gframes,
-                                    gnttab_max_grant_frames(),
-                                    &gnttab_shared.addr);
-        BUG_ON(rc);
-        return 0;
-}
-static void gnttab_unmap_frames_v1(void)
-{
-        arch_gnttab_unmap(gnttab_shared.addr, nr_grant_frames);
-}
-static int gnttab_map_frames_v2(xen_pfn_t *frames, unsigned int nr_gframes)
-{
-        uint64_t *sframes;
-        unsigned int nr_sframes;
-        struct gnttab_get_status_frames getframes;
-        int rc;
-        nr_sframes = nr_status_frames(nr_gframes);
-        /* No need for kzalloc as it is initialized in following hypercall
-         * GNTTABOP_get_status_frames.
-         */
-        sframes = kmalloc(nr_sframes  * sizeof(uint64_t), GFP_ATOMIC);
-        if (!sframes)
-                return -ENOMEM;
-        getframes.dom        = DOMID_SELF;
-        getframes.nr_frames  = nr_sframes;
-        set_xen_guest_handle(getframes.frame_list, sframes);
-        rc = HYPERVISOR_grant_table_op(GNTTABOP_get_status_frames,
-                                       &getframes, 1);
-        if (rc == -ENOSYS) {
-                kfree(sframes);
-                return -ENOSYS;
-        }
-        BUG_ON(rc || getframes.status);
-        rc = arch_gnttab_map_status(sframes, nr_sframes,
-                                    nr_status_frames(gnttab_max_grant_frames()),
-                                    &grstatus);
-        BUG_ON(rc);
-        kfree(sframes);
-        rc = arch_gnttab_map_shared(frames, nr_gframes,
-                                    gnttab_max_grant_frames(),
-                                    &gnttab_shared.addr);
-        BUG_ON(rc);
-        return 0;
-}
-static void gnttab_unmap_frames_v2(void)
-{
-        arch_gnttab_unmap(gnttab_shared.addr, nr_grant_frames);
-        arch_gnttab_unmap(grstatus, nr_status_frames(nr_grant_frames));
-}
 static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
 {
        struct gnttab_setup_table setup;
-        xen_pfn_t *frames;
+        unsigned long *frames;
        unsigned int nr_gframes = end_idx + 1;
        int rc;
@@ -1057,9 +551,6 @@ static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
                return rc;
        }
-        /* No need for kzalloc as it is initialized in following hypercall
-         * GNTTABOP_setup_table.
-         */
        frames = kmalloc(nr_gframes * sizeof(unsigned long), GFP_ATOMIC);
        if (!frames)
                return -ENOMEM;
@@ -1076,68 +567,19 @@ static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
        BUG_ON(rc || setup.status);
-        rc = gnttab_interface->map_frames(frames, nr_gframes);
+        rc = arch_gnttab_map_shared(frames, nr_gframes, gnttab_max_grant_frames(),
+                                    &shared);
+        BUG_ON(rc);
        kfree(frames);
-        return rc;
+        return 0;
-}
-static struct gnttab_ops gnttab_v1_ops = {
-        .map_frames                     = gnttab_map_frames_v1,
-        .unmap_frames                   = gnttab_unmap_frames_v1,
-        .update_entry                   = gnttab_update_entry_v1,
-        .end_foreign_access_ref         = gnttab_end_foreign_access_ref_v1,
-        .end_foreign_transfer_ref       = gnttab_end_foreign_transfer_ref_v1,
-        .query_foreign_access           = gnttab_query_foreign_access_v1,
-};
-static struct gnttab_ops gnttab_v2_ops = {
-        .map_frames                     = gnttab_map_frames_v2,
-        .unmap_frames                   = gnttab_unmap_frames_v2,
-        .update_entry                   = gnttab_update_entry_v2,
-        .end_foreign_access_ref         = gnttab_end_foreign_access_ref_v2,
-        .end_foreign_transfer_ref       = gnttab_end_foreign_transfer_ref_v2,
-        .query_foreign_access           = gnttab_query_foreign_access_v2,
-        .update_subpage_entry           = gnttab_update_subpage_entry_v2,
-        .update_trans_entry             = gnttab_update_trans_entry_v2,
-};
-static void gnttab_request_version(void)
-{
-        int rc;
-        struct gnttab_set_version gsv;
-        if (xen_hvm_domain())
-                gsv.version = 1;
-        else
-                gsv.version = 2;
-        rc = HYPERVISOR_grant_table_op(GNTTABOP_set_version, &gsv, 1);
-        if (rc == 0 && gsv.version == 2) {
-                grant_table_version = 2;
-                gnttab_interface = &gnttab_v2_ops;
-        } else if (grant_table_version == 2) {
-                /*
-                 * If we've already used version 2 features,
-                 * but then suddenly discover that they're not
-                 * available (e.g. migrating to an older
-                 * version of Xen), almost unbounded badness
-                 * can happen.
-                 */
-                panic("we need grant tables version 2, but only version 1 is available");
-        } else {
-                grant_table_version = 1;
-                gnttab_interface = &gnttab_v1_ops;
-        }
-        printk(KERN_INFO "Grant tables using version %d layout.\n",
-                grant_table_version);
 }
 int gnttab_resume(void)
 {
        unsigned int max_nr_gframes;
-        gnttab_request_version();
        max_nr_gframes = gnttab_max_grant_frames();
        if (max_nr_gframes < nr_grant_frames)
                return -ENOSYS;
@@ -1145,10 +587,9 @@ int gnttab_resume(void)
        if (xen_pv_domain())
                return gnttab_map(0, nr_grant_frames - 1);
-        if (gnttab_shared.addr == NULL) {
+        if (!shared) {
-                gnttab_shared.addr = ioremap(xen_hvm_resume_frames,
+                shared = ioremap(xen_hvm_resume_frames, PAGE_SIZE * max_nr_gframes);
-                                                PAGE_SIZE * max_nr_gframes);
+                if (shared == NULL) {
-                if (gnttab_shared.addr == NULL) {
                        printk(KERN_WARNING
                                        "Failed to ioremap gnttab share frames!");
                        return -ENOMEM;
@@ -1162,7 +603,7 @@ int gnttab_resume(void)
 int gnttab_suspend(void)
 {
-        gnttab_interface->unmap_frames();
+        arch_gnttab_unmap_shared(shared, nr_grant_frames);
        return 0;
 }
@@ -1189,7 +630,6 @@ int gnttab_init(void)
        int i;
        unsigned int max_nr_glist_frames, nr_glist_frames;
        unsigned int nr_init_grefs;
-        int ret;
        nr_grant_frames = 1;
        boot_max_nr_grant_frames = __max_nr_grant_frames();
@@ -1208,16 +648,12 @@ int gnttab_init(void)
        nr_glist_frames = (nr_grant_frames * GREFS_PER_GRANT_FRAME + RPP - 1) / RPP;
        for (i = 0; i < nr_glist_frames; i++) {
                gnttab_list[i] = (grant_ref_t *)__get_free_page(GFP_KERNEL);
-                if (gnttab_list[i] == NULL) {
+                if (gnttab_list[i] == NULL)
-                        ret = -ENOMEM;
                        goto ini_nomem;
-                }
        }
-        if (gnttab_resume() < 0) {
+        if (gnttab_resume() < 0)
-                ret = -ENODEV;
+                return -ENODEV;
-                goto ini_nomem;
-        }
        nr_init_grefs = nr_grant_frames * GREFS_PER_GRANT_FRAME;
@@ -1235,11 +671,11 @@ int gnttab_init(void)
        for (i--; i >= 0; i--)
                free_page((unsigned long)gnttab_list[i]);
        kfree(gnttab_list);
-        return ret;
+        return -ENOMEM;
 }
 EXPORT_SYMBOL_GPL(gnttab_init);
-static int __gnttab_init(void)
+static int __devinit __gnttab_init(void)
 {
        /* Delay grant-table initialization in the PV on HVM case */
        if (xen_hvm_domain())
diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
index 412b96cc530..0b5366b5be2 100644
--- a/drivers/xen/manage.c
+++ b/drivers/xen/manage.c
@@ -9,7 +9,6 @@
 #include <linux/stop_machine.h>
 #include <linux/freezer.h>
 #include <linux/syscore_ops.h>
-#include <linux/export.h>
 #include <xen/xen.h>
 #include <xen/xenbus.h>
@@ -129,10 +128,9 @@ static void do_suspend(void)
        printk(KERN_DEBUG "suspending xenstore...\n");
        xs_suspend();
-        err = dpm_suspend_end(PMSG_FREEZE);
+        err = dpm_suspend_noirq(PMSG_FREEZE);
        if (err) {
-                printk(KERN_ERR "dpm_suspend_end failed: %d\n", err);
+                printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
-                si.cancelled = 0;
                goto out_resume;
        }
@@ -150,7 +148,7 @@ static void do_suspend(void)
        err = stop_machine(xen_suspend, &si, cpumask_of(0));
-        dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
+        dpm_resume_noirq(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
        if (err) {
                printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
diff --git a/drivers/xen/mcelog.c b/drivers/xen/mcelog.c
deleted file mode 100644
index 8feee08bcb4..00000000000
--- a/drivers/xen/mcelog.c
+++ /dev/null
@@ -1,414 +0,0 @@
-/******************************************************************************
- * mcelog.c
- * Driver for receiving and transferring machine check error infomation
- *
- * Copyright (c) 2012 Intel Corporation
- * Author: Liu, Jinsong <jinsong.liu@intel.com>
- * Author: Jiang, Yunhong <yunhong.jiang@intel.com>
- * Author: Ke, Liping <liping.ke@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include <linux/init.h>
-#include <linux/types.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/fs.h>
-#include <linux/device.h>
-#include <linux/miscdevice.h>
-#include <linux/uaccess.h>
-#include <linux/capability.h>
-#include <linux/poll.h>
-#include <linux/sched.h>
-#include <xen/interface/xen.h>
-#include <xen/events.h>
-#include <xen/interface/vcpu.h>
-#include <xen/xen.h>
-#include <asm/xen/hypercall.h>
-#include <asm/xen/hypervisor.h>
-#define XEN_MCELOG "xen_mcelog: "
-static struct mc_info g_mi;
-static struct mcinfo_logical_cpu *g_physinfo;
-static uint32_t ncpus;
-static DEFINE_MUTEX(mcelog_lock);
-static struct xen_mce_log xen_mcelog = {
-        .signature      = XEN_MCE_LOG_SIGNATURE,
-        .len            = XEN_MCE_LOG_LEN,
-        .recordlen      = sizeof(struct xen_mce),
-};
-static DEFINE_SPINLOCK(xen_mce_chrdev_state_lock);
-static int xen_mce_chrdev_open_count;   /* #times opened */
-static int xen_mce_chrdev_open_exclu;   /* already open exclusive? */
-static DECLARE_WAIT_QUEUE_HEAD(xen_mce_chrdev_wait);
-static int xen_mce_chrdev_open(struct inode *inode, struct file *file)
-{
-        spin_lock(&xen_mce_chrdev_state_lock);
-        if (xen_mce_chrdev_open_exclu ||
-            (xen_mce_chrdev_open_count && (file->f_flags & O_EXCL))) {
-                spin_unlock(&xen_mce_chrdev_state_lock);
-                return -EBUSY;
-        }
-        if (file->f_flags & O_EXCL)
-                xen_mce_chrdev_open_exclu = 1;
-        xen_mce_chrdev_open_count++;
-        spin_unlock(&xen_mce_chrdev_state_lock);
-        return nonseekable_open(inode, file);
-}
-static int xen_mce_chrdev_release(struct inode *inode, struct file *file)
-{
-        spin_lock(&xen_mce_chrdev_state_lock);
-        xen_mce_chrdev_open_count--;
-        xen_mce_chrdev_open_exclu = 0;
-        spin_unlock(&xen_mce_chrdev_state_lock);
-        return 0;
-}
-static ssize_t xen_mce_chrdev_read(struct file *filp, char __user *ubuf,
-                                size_t usize, loff_t *off)
-{
-        char __user *buf = ubuf;
-        unsigned num;
-        int i, err;
-        mutex_lock(&mcelog_lock);
-        num = xen_mcelog.next;
-        /* Only supports full reads right now */
-        err = -EINVAL;
-        if (*off != 0 || usize < XEN_MCE_LOG_LEN*sizeof(struct xen_mce))
-                goto out;
-        err = 0;
-        for (i = 0; i < num; i++) {
-                struct xen_mce *m = &xen_mcelog.entry[i];
-                err |= copy_to_user(buf, m, sizeof(*m));
-                buf += sizeof(*m);
-        }
-        memset(xen_mcelog.entry, 0, num * sizeof(struct xen_mce));
-        xen_mcelog.next = 0;
-        if (err)
-                err = -EFAULT;
-out:
-        mutex_unlock(&mcelog_lock);
-        return err ? err : buf - ubuf;
-}
-static unsigned int xen_mce_chrdev_poll(struct file *file, poll_table *wait)
-{
-        poll_wait(file, &xen_mce_chrdev_wait, wait);
-        if (xen_mcelog.next)
-                return POLLIN | POLLRDNORM;
-        return 0;
-}
-static long xen_mce_chrdev_ioctl(struct file *f, unsigned int cmd,
-                                unsigned long arg)
-{
-        int __user *p = (int __user *)arg;
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        switch (cmd) {
-        case MCE_GET_RECORD_LEN:
-                return put_user(sizeof(struct xen_mce), p);
-        case MCE_GET_LOG_LEN:
-                return put_user(XEN_MCE_LOG_LEN, p);
-        case MCE_GETCLEAR_FLAGS: {
-                unsigned flags;
-                do {
-                        flags = xen_mcelog.flags;
-                } while (cmpxchg(&xen_mcelog.flags, flags, 0) != flags);
-                return put_user(flags, p);
-        }
-        default:
-                return -ENOTTY;
-        }
-}
-static const struct file_operations xen_mce_chrdev_ops = {
-        .open                   = xen_mce_chrdev_open,
-        .release                = xen_mce_chrdev_release,
-        .read                   = xen_mce_chrdev_read,
-        .poll                   = xen_mce_chrdev_poll,
-        .unlocked_ioctl         = xen_mce_chrdev_ioctl,
-        .llseek                 = no_llseek,
-};
-static struct miscdevice xen_mce_chrdev_device = {
-        MISC_MCELOG_MINOR,
-        "mcelog",
-        &xen_mce_chrdev_ops,
-};
-/*
- * Caller should hold the mcelog_lock
- */
-static void xen_mce_log(struct xen_mce *mce)
-{
-        unsigned entry;
-        entry = xen_mcelog.next;
-        /*
-         * When the buffer fills up discard new entries.
-         * Assume that the earlier errors are the more
-         * interesting ones:
-         */
-        if (entry >= XEN_MCE_LOG_LEN) {
-                set_bit(XEN_MCE_OVERFLOW,
-                        (unsigned long *)&xen_mcelog.flags);
-                return;
-        }
-        memcpy(xen_mcelog.entry + entry, mce, sizeof(struct xen_mce));
-        xen_mcelog.next++;
-}
-static int convert_log(struct mc_info *mi)
-{
-        struct mcinfo_common *mic;
-        struct mcinfo_global *mc_global;
-        struct mcinfo_bank *mc_bank;
-        struct xen_mce m;
-        uint32_t i;
-        mic = NULL;
-        x86_mcinfo_lookup(&mic, mi, MC_TYPE_GLOBAL);
-        if (unlikely(!mic)) {
-                pr_warning(XEN_MCELOG "Failed to find global error info\n");
-                return -ENODEV;
-        }
-        memset(&m, 0, sizeof(struct xen_mce));
-        mc_global = (struct mcinfo_global *)mic;
-        m.mcgstatus = mc_global->mc_gstatus;
-        m.apicid = mc_global->mc_apicid;
-        for (i = 0; i < ncpus; i++)
-                if (g_physinfo[i].mc_apicid == m.apicid)
-                        break;
-        if (unlikely(i == ncpus)) {
-                pr_warning(XEN_MCELOG "Failed to match cpu with apicid %d\n",
-                           m.apicid);
-                return -ENODEV;
-        }
-        m.socketid = g_physinfo[i].mc_chipid;
-        m.cpu = m.extcpu = g_physinfo[i].mc_cpunr;
-        m.cpuvendor = (__u8)g_physinfo[i].mc_vendor;
-        m.mcgcap = g_physinfo[i].mc_msrvalues[__MC_MSR_MCGCAP].value;
-        mic = NULL;
-        x86_mcinfo_lookup(&mic, mi, MC_TYPE_BANK);
-        if (unlikely(!mic)) {
-                pr_warning(XEN_MCELOG "Fail to find bank error info\n");
-                return -ENODEV;
-        }
-        do {
-                if ((!mic) || (mic->size == 0) ||
-                    (mic->type != MC_TYPE_GLOBAL   &&
-                     mic->type != MC_TYPE_BANK     &&
-                     mic->type != MC_TYPE_EXTENDED &&
-                     mic->type != MC_TYPE_RECOVERY))
-                        break;
-                if (mic->type == MC_TYPE_BANK) {
-                        mc_bank = (struct mcinfo_bank *)mic;
-                        m.misc = mc_bank->mc_misc;
-                        m.status = mc_bank->mc_status;
-                        m.addr = mc_bank->mc_addr;
-                        m.tsc = mc_bank->mc_tsc;
-                        m.bank = mc_bank->mc_bank;
-                        m.finished = 1;
-                        /*log this record*/
-                        xen_mce_log(&m);
-                }
-                mic = x86_mcinfo_next(mic);
-        } while (1);
-        return 0;
-}
-static int mc_queue_handle(uint32_t flags)
-{
-        struct xen_mc mc_op;
-        int ret = 0;
-        mc_op.cmd = XEN_MC_fetch;
-        mc_op.interface_version = XEN_MCA_INTERFACE_VERSION;
-        set_xen_guest_handle(mc_op.u.mc_fetch.data, &g_mi);
-        do {
-                mc_op.u.mc_fetch.flags = flags;
-                ret = HYPERVISOR_mca(&mc_op);
-                if (ret) {
-                        pr_err(XEN_MCELOG "Failed to fetch %s error log\n",
-                               (flags == XEN_MC_URGENT) ?
-                               "urgnet" : "nonurgent");
-                        break;
-                }
-                if (mc_op.u.mc_fetch.flags & XEN_MC_NODATA ||
-                    mc_op.u.mc_fetch.flags & XEN_MC_FETCHFAILED)
-                        break;
-                else {
-                        ret = convert_log(&g_mi);
-                        if (ret)
-                                pr_warning(XEN_MCELOG
-                                           "Failed to convert this error log, "
-                                           "continue acking it anyway\n");
-                        mc_op.u.mc_fetch.flags = flags | XEN_MC_ACK;
-                        ret = HYPERVISOR_mca(&mc_op);
-                        if (ret) {
-                                pr_err(XEN_MCELOG
-                                       "Failed to ack previous error log\n");
-                                break;
-                        }
-                }
-        } while (1);
-        return ret;
-}
-/* virq handler for machine check error info*/
-static void xen_mce_work_fn(struct work_struct *work)
-{
-        int err;
-        mutex_lock(&mcelog_lock);
-        /* urgent mc_info */
-        err = mc_queue_handle(XEN_MC_URGENT);
-        if (err)
-                pr_err(XEN_MCELOG
-                       "Failed to handle urgent mc_info queue, "
-                       "continue handling nonurgent mc_info queue anyway.\n");
-        /* nonurgent mc_info */
-        err = mc_queue_handle(XEN_MC_NONURGENT);
-        if (err)
-                pr_err(XEN_MCELOG
-                       "Failed to handle nonurgent mc_info queue.\n");
-        /* wake processes polling /dev/mcelog */
-        wake_up_interruptible(&xen_mce_chrdev_wait);
-        mutex_unlock(&mcelog_lock);
-}
-static DECLARE_WORK(xen_mce_work, xen_mce_work_fn);
-static irqreturn_t xen_mce_interrupt(int irq, void *dev_id)
-{
-        schedule_work(&xen_mce_work);
-        return IRQ_HANDLED;
-}
-static int bind_virq_for_mce(void)
-{
-        int ret;
-        struct xen_mc mc_op;
-        memset(&mc_op, 0, sizeof(struct xen_mc));
-        /* Fetch physical CPU Numbers */
-        mc_op.cmd = XEN_MC_physcpuinfo;
-        mc_op.interface_version = XEN_MCA_INTERFACE_VERSION;
-        set_xen_guest_handle(mc_op.u.mc_physcpuinfo.info, g_physinfo);
-        ret = HYPERVISOR_mca(&mc_op);
-        if (ret) {
-                pr_err(XEN_MCELOG "Failed to get CPU numbers\n");
-                return ret;
-        }
-        /* Fetch each CPU Physical Info for later reference*/
-        ncpus = mc_op.u.mc_physcpuinfo.ncpus;
-        g_physinfo = kcalloc(ncpus, sizeof(struct mcinfo_logical_cpu),
-                             GFP_KERNEL);
-        if (!g_physinfo)
-                return -ENOMEM;
-        set_xen_guest_handle(mc_op.u.mc_physcpuinfo.info, g_physinfo);
-        ret = HYPERVISOR_mca(&mc_op);
-        if (ret) {
-                pr_err(XEN_MCELOG "Failed to get CPU info\n");
-                kfree(g_physinfo);
-                return ret;
-        }
-        ret  = bind_virq_to_irqhandler(VIRQ_MCA, 0,
-                                       xen_mce_interrupt, 0, "mce", NULL);
-        if (ret < 0) {
-                pr_err(XEN_MCELOG "Failed to bind virq\n");
-                kfree(g_physinfo);
-                return ret;
-        }
-        return 0;
-}
-static int __init xen_late_init_mcelog(void)
-{
-        /* Only DOM0 is responsible for MCE logging */
-        if (xen_initial_domain()) {
-                /* register character device /dev/mcelog for xen mcelog */
-                if (misc_register(&xen_mce_chrdev_device))
-                        return -ENODEV;
-                return bind_virq_for_mce();
-        }
-        return -ENODEV;
-}
-device_initcall(xen_late_init_mcelog);
diff --git a/drivers/xen/pci.c b/drivers/xen/pci.c
index 18fff88254e..cef4bafc07d 100644
--- a/drivers/xen/pci.c
+++ b/drivers/xen/pci.c
@@ -18,7 +18,6 @@
 */
 #include <linux/pci.h>
-#include <linux/acpi.h>
 #include <xen/xen.h>
 #include <xen/interface/physdev.h>
 #include <xen/interface/xen.h>
@@ -27,85 +26,26 @@
 #include <asm/xen/hypercall.h>
 #include "../pci/pci.h"
-static bool __read_mostly pci_seg_supported = true;
 static int xen_add_device(struct device *dev)
 {
        int r;
        struct pci_dev *pci_dev = to_pci_dev(dev);
-#ifdef CONFIG_PCI_IOV
-        struct pci_dev *physfn = pci_dev->physfn;
-#endif
-        if (pci_seg_supported) {
-                struct physdev_pci_device_add add = {
-                        .seg = pci_domain_nr(pci_dev->bus),
-                        .bus = pci_dev->bus->number,
-                        .devfn = pci_dev->devfn
-                };
-#ifdef CONFIG_ACPI
-                acpi_handle handle;
-#endif
-#ifdef CONFIG_PCI_IOV
-                if (pci_dev->is_virtfn) {
-                        add.flags = XEN_PCI_DEV_VIRTFN;
-                        add.physfn.bus = physfn->bus->number;
-                        add.physfn.devfn = physfn->devfn;
-                } else
-#endif
-                if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn))
-                        add.flags = XEN_PCI_DEV_EXTFN;
-#ifdef CONFIG_ACPI
-                handle = DEVICE_ACPI_HANDLE(&pci_dev->dev);
-                if (!handle && pci_dev->bus->bridge)
-                        handle = DEVICE_ACPI_HANDLE(pci_dev->bus->bridge);
-#ifdef CONFIG_PCI_IOV
-                if (!handle && pci_dev->is_virtfn)
-                        handle = DEVICE_ACPI_HANDLE(physfn->bus->bridge);
-#endif
-                if (handle) {
-                        acpi_status status;
-                        do {
-                                unsigned long long pxm;
-                                status = acpi_evaluate_integer(handle, "_PXM",
-                                                               NULL, &pxm);
-                                if (ACPI_SUCCESS(status)) {
-                                        add.optarr[0] = pxm;
-                                        add.flags |= XEN_PCI_DEV_PXM;
-                                        break;
-                                }
-                                status = acpi_get_parent(handle, &handle);
-                        } while (ACPI_SUCCESS(status));
-                }
-#endif /* CONFIG_ACPI */
-                r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_add, &add);
-                if (r != -ENOSYS)
-                        return r;
-                pci_seg_supported = false;
-        }
-        if (pci_domain_nr(pci_dev->bus))
-                r = -ENOSYS;
 #ifdef CONFIG_PCI_IOV
-        else if (pci_dev->is_virtfn) {
+        if (pci_dev->is_virtfn) {
                struct physdev_manage_pci_ext manage_pci_ext = {
                        .bus            = pci_dev->bus->number,
                        .devfn          = pci_dev->devfn,
                        .is_virtfn      = 1,
-                        .physfn.bus     = physfn->bus->number,
+                        .physfn.bus     = pci_dev->physfn->bus->number,
-                        .physfn.devfn   = physfn->devfn,
+                        .physfn.devfn   = pci_dev->physfn->devfn,
                };
                r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_add_ext,
                        &manage_pci_ext);
-        }
+        } else
 #endif
-        else if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn)) {
+        if (pci_ari_enabled(pci_dev->bus) && PCI_SLOT(pci_dev->devfn)) {
                struct physdev_manage_pci_ext manage_pci_ext = {
                        .bus            = pci_dev->bus->number,
                        .devfn          = pci_dev->devfn,
@@ -116,7 +56,7 @@ static int xen_add_device(struct device *dev)
                        &manage_pci_ext);
        } else {
                struct physdev_manage_pci manage_pci = {
-                        .bus    = pci_dev->bus->number,
+                        .bus    = pci_dev->bus->number,
                        .devfn  = pci_dev->devfn,
                };
@@ -131,27 +71,13 @@ static int xen_remove_device(struct device *dev)
 {
        int r;
        struct pci_dev *pci_dev = to_pci_dev(dev);
+        struct physdev_manage_pci manage_pci;
-        if (pci_seg_supported) {
+        manage_pci.bus = pci_dev->bus->number;
-                struct physdev_pci_device device = {
+        manage_pci.devfn = pci_dev->devfn;
-                        .seg = pci_domain_nr(pci_dev->bus),
-                        .bus = pci_dev->bus->number,
-                        .devfn = pci_dev->devfn
-                };
-                r = HYPERVISOR_physdev_op(PHYSDEVOP_pci_device_remove,
+        r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_remove,
-                                          &device);
+                &manage_pci);
-        } else if (pci_domain_nr(pci_dev->bus))
-                r = -ENOSYS;
-        else {
-                struct physdev_manage_pci manage_pci = {
-                        .bus = pci_dev->bus->number,
-                        .devfn = pci_dev->devfn
-                };
-                r = HYPERVISOR_physdev_op(PHYSDEVOP_manage_pci_remove,
-                                          &manage_pci);
-        }
        return r;
 }
@@ -170,16 +96,13 @@ static int xen_pci_notifier(struct notifier_block *nb,
                r = xen_remove_device(dev);
                break;
        default:
-                return NOTIFY_DONE;
+                break;
        }
-        if (r)
-                dev_err(dev, "Failed to %s - passthrough or MSI/MSI-X might fail!\n",
+        return r;
-                        action == BUS_NOTIFY_ADD_DEVICE ? "add" :
-                        (action == BUS_NOTIFY_DEL_DEVICE ? "delete" : "?"));
-        return NOTIFY_OK;
 }
-static struct notifier_block device_nb = {
+struct notifier_block device_nb = {
        .notifier_call = xen_pci_notifier,
 };
diff --git a/drivers/xen/pcpu.c b/drivers/xen/pcpu.c
deleted file mode 100644
index 067fcfa1723..00000000000
--- a/drivers/xen/pcpu.c
+++ /dev/null
@@ -1,371 +0,0 @@
-/******************************************************************************
- * pcpu.c
- * Management physical cpu in dom0, get pcpu info and provide sys interface
- *
- * Copyright (c) 2012 Intel Corporation
- * Author: Liu, Jinsong <jinsong.liu@intel.com>
- * Author: Jiang, Yunhong <yunhong.jiang@intel.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#include <linux/interrupt.h>
-#include <linux/spinlock.h>
-#include <linux/cpu.h>
-#include <linux/stat.h>
-#include <linux/capability.h>
-#include <xen/xen.h>
-#include <xen/xenbus.h>
-#include <xen/events.h>
-#include <xen/interface/platform.h>
-#include <asm/xen/hypervisor.h>
-#include <asm/xen/hypercall.h>
-#define XEN_PCPU "xen_cpu: "
-/*
- * @cpu_id: Xen physical cpu logic number
- * @flags: Xen physical cpu status flag
- * - XEN_PCPU_FLAGS_ONLINE: cpu is online
- * - XEN_PCPU_FLAGS_INVALID: cpu is not present
- */
-struct pcpu {
-        struct list_head list;
-        struct device dev;
-        uint32_t cpu_id;
-        uint32_t flags;
-};
-static struct bus_type xen_pcpu_subsys = {
-        .name = "xen_cpu",
-        .dev_name = "xen_cpu",
-};
-static DEFINE_MUTEX(xen_pcpu_lock);
-static LIST_HEAD(xen_pcpus);
-static int xen_pcpu_down(uint32_t cpu_id)
-{
-        struct xen_platform_op op = {
-                .cmd                    = XENPF_cpu_offline,
-                .interface_version      = XENPF_INTERFACE_VERSION,
-                .u.cpu_ol.cpuid         = cpu_id,
-        };
-        return HYPERVISOR_dom0_op(&op);
-}
-static int xen_pcpu_up(uint32_t cpu_id)
-{
-        struct xen_platform_op op = {
-                .cmd                    = XENPF_cpu_online,
-                .interface_version      = XENPF_INTERFACE_VERSION,
-                .u.cpu_ol.cpuid         = cpu_id,
-        };
-        return HYPERVISOR_dom0_op(&op);
-}
-static ssize_t show_online(struct device *dev,
-                           struct device_attribute *attr,
-                           char *buf)
-{
-        struct pcpu *cpu = container_of(dev, struct pcpu, dev);
-        return sprintf(buf, "%u\n", !!(cpu->flags & XEN_PCPU_FLAGS_ONLINE));
-}
-static ssize_t __ref store_online(struct device *dev,
-                                  struct device_attribute *attr,
-                                  const char *buf, size_t count)
-{
-        struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
-        unsigned long long val;
-        ssize_t ret;
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        if (kstrtoull(buf, 0, &val) < 0)
-                return -EINVAL;
-        switch (val) {
-        case 0:
-                ret = xen_pcpu_down(pcpu->cpu_id);
-                break;
-        case 1:
-                ret = xen_pcpu_up(pcpu->cpu_id);
-                break;
-        default:
-                ret = -EINVAL;
-        }
-        if (ret >= 0)
-                ret = count;
-        return ret;
-}
-static DEVICE_ATTR(online, S_IRUGO | S_IWUSR, show_online, store_online);
-static bool xen_pcpu_online(uint32_t flags)
-{
-        return !!(flags & XEN_PCPU_FLAGS_ONLINE);
-}
-static void pcpu_online_status(struct xenpf_pcpuinfo *info,
-                               struct pcpu *pcpu)
-{
-        if (xen_pcpu_online(info->flags) &&
-           !xen_pcpu_online(pcpu->flags)) {
-                /* the pcpu is onlined */
-                pcpu->flags |= XEN_PCPU_FLAGS_ONLINE;
-                kobject_uevent(&pcpu->dev.kobj, KOBJ_ONLINE);
-        } else if (!xen_pcpu_online(info->flags) &&
-                    xen_pcpu_online(pcpu->flags)) {
-                /* The pcpu is offlined */
-                pcpu->flags &= ~XEN_PCPU_FLAGS_ONLINE;
-                kobject_uevent(&pcpu->dev.kobj, KOBJ_OFFLINE);
-        }
-}
-static struct pcpu *get_pcpu(uint32_t cpu_id)
-{
-        struct pcpu *pcpu;
-        list_for_each_entry(pcpu, &xen_pcpus, list) {
-                if (pcpu->cpu_id == cpu_id)
-                        return pcpu;
-        }
-        return NULL;
-}
-static void pcpu_release(struct device *dev)
-{
-        struct pcpu *pcpu = container_of(dev, struct pcpu, dev);
-        list_del(&pcpu->list);
-        kfree(pcpu);
-}
-static void unregister_and_remove_pcpu(struct pcpu *pcpu)
-{
-        struct device *dev;
-        if (!pcpu)
-                return;
-        dev = &pcpu->dev;
-        if (dev->id)
-                device_remove_file(dev, &dev_attr_online);
-        /* pcpu remove would be implicitly done */
-        device_unregister(dev);
-}
-static int register_pcpu(struct pcpu *pcpu)
-{
-        struct device *dev;
-        int err = -EINVAL;
-        if (!pcpu)
-                return err;
-        dev = &pcpu->dev;
-        dev->bus = &xen_pcpu_subsys;
-        dev->id = pcpu->cpu_id;
-        dev->release = pcpu_release;
-        err = device_register(dev);
-        if (err) {
-                pcpu_release(dev);
-                return err;
-        }
-        /*
-         * Xen never offline cpu0 due to several restrictions
-         * and assumptions. This basically doesn't add a sys control
-         * to user, one cannot attempt to offline BSP.
-         */
-        if (dev->id) {
-                err = device_create_file(dev, &dev_attr_online);
-                if (err) {
-                        device_unregister(dev);
-                        return err;
-                }
-        }
-        return 0;
-}
-static struct pcpu *create_and_register_pcpu(struct xenpf_pcpuinfo *info)
-{
-        struct pcpu *pcpu;
-        int err;
-        if (info->flags & XEN_PCPU_FLAGS_INVALID)
-                return ERR_PTR(-ENODEV);
-        pcpu = kzalloc(sizeof(struct pcpu), GFP_KERNEL);
-        if (!pcpu)
-                return ERR_PTR(-ENOMEM);
-        INIT_LIST_HEAD(&pcpu->list);
-        pcpu->cpu_id = info->xen_cpuid;
-        pcpu->flags = info->flags;
-        /* Need hold on xen_pcpu_lock before pcpu list manipulations */
-        list_add_tail(&pcpu->list, &xen_pcpus);
-        err = register_pcpu(pcpu);
-        if (err) {
-                pr_warning(XEN_PCPU "Failed to register pcpu%u\n",
-                           info->xen_cpuid);
-                return ERR_PTR(-ENOENT);
-        }
-        return pcpu;
-}
-/*
- * Caller should hold the xen_pcpu_lock
- */
-static int sync_pcpu(uint32_t cpu, uint32_t *max_cpu)
-{
-        int ret;
-        struct pcpu *pcpu = NULL;
-        struct xenpf_pcpuinfo *info;
-        struct xen_platform_op op = {
-                .cmd                   = XENPF_get_cpuinfo,
-                .interface_version     = XENPF_INTERFACE_VERSION,
-                .u.pcpu_info.xen_cpuid = cpu,
-        };
-        ret = HYPERVISOR_dom0_op(&op);
-        if (ret)
-                return ret;
-        info = &op.u.pcpu_info;
-        if (max_cpu)
-                *max_cpu = info->max_present;
-        pcpu = get_pcpu(cpu);
-        /*
-         * Only those at cpu present map has its sys interface.
-         */
-        if (info->flags & XEN_PCPU_FLAGS_INVALID) {
-                if (pcpu)
-                        unregister_and_remove_pcpu(pcpu);
-                return 0;
-        }
-        if (!pcpu) {
-                pcpu = create_and_register_pcpu(info);
-                if (IS_ERR_OR_NULL(pcpu))
-                        return -ENODEV;
-        } else
-                pcpu_online_status(info, pcpu);
-        return 0;
-}
-/*
- * Sync dom0's pcpu information with xen hypervisor's
- */
-static int xen_sync_pcpus(void)
-{
-        /*
-         * Boot cpu always have cpu_id 0 in xen
-         */
-        uint32_t cpu = 0, max_cpu = 0;
-        int err = 0;
-        struct pcpu *pcpu, *tmp;
-        mutex_lock(&xen_pcpu_lock);
-        while (!err && (cpu <= max_cpu)) {
-                err = sync_pcpu(cpu, &max_cpu);
-                cpu++;
-        }
-        if (err)
-                list_for_each_entry_safe(pcpu, tmp, &xen_pcpus, list)
-                        unregister_and_remove_pcpu(pcpu);
-        mutex_unlock(&xen_pcpu_lock);
-        return err;
-}
-static void xen_pcpu_work_fn(struct work_struct *work)
-{
-        xen_sync_pcpus();
-}
-static DECLARE_WORK(xen_pcpu_work, xen_pcpu_work_fn);
-static irqreturn_t xen_pcpu_interrupt(int irq, void *dev_id)
-{
-        schedule_work(&xen_pcpu_work);
-        return IRQ_HANDLED;
-}
-static int __init xen_pcpu_init(void)
-{
-        int irq, ret;
-        if (!xen_initial_domain())
-                return -ENODEV;
-        irq = bind_virq_to_irqhandler(VIRQ_PCPU_STATE, 0,
-                                      xen_pcpu_interrupt, 0,
-                                      "xen-pcpu", NULL);
-        if (irq < 0) {
-                pr_warning(XEN_PCPU "Failed to bind pcpu virq\n");
-                return irq;
-        }
-        ret = subsys_system_register(&xen_pcpu_subsys, NULL);
-        if (ret) {
-                pr_warning(XEN_PCPU "Failed to register pcpu subsys\n");
-                goto err1;
-        }
-        ret = xen_sync_pcpus();
-        if (ret) {
-                pr_warning(XEN_PCPU "Failed to sync pcpu info\n");
-                goto err2;
-        }
-        return 0;
-err2:
-        bus_unregister(&xen_pcpu_subsys);
-err1:
-        unbind_from_irqhandler(irq, NULL);
-        return ret;
-}
-arch_initcall(xen_pcpu_init);
diff --git a/drivers/xen/platform-pci.c b/drivers/xen/platform-pci.c
index 99db9e1eb8b..319dd0a94d5 100644
--- a/drivers/xen/platform-pci.c
+++ b/drivers/xen/platform-pci.c
@@ -101,17 +101,14 @@ static int platform_pci_resume(struct pci_dev *pdev)
        return 0;
 }
-static int platform_pci_init(struct pci_dev *pdev,
+static int __devinit platform_pci_init(struct pci_dev *pdev,
-                             const struct pci_device_id *ent)
+                                       const struct pci_device_id *ent)
 {
        int i, ret;
        long ioaddr;
        long mmio_addr, mmio_len;
        unsigned int max_nr_gframes;
-        if (!xen_domain())
-                return -ENODEV;
        i = pci_enable_device(pdev);
        if (i)
                return i;
@@ -170,7 +167,7 @@ pci_out:
        return ret;
 }
-static struct pci_device_id platform_pci_tbl[] = {
+static struct pci_device_id platform_pci_tbl[] __devinitdata = {
        {PCI_VENDOR_ID_XEN, PCI_DEVICE_ID_XEN_PLATFORM,
                PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
        {0,}
@@ -189,6 +186,11 @@ static struct pci_driver platform_driver = {
 static int __init platform_pci_module_init(void)
 {
+        /* no unplug has been done, IGNORE hasn't been specified: just
+         * return now */
+        if (!xen_platform_pci_unplug)
+                return -ENODEV;
        return pci_register_driver(&platform_driver);
 }
diff --git a/drivers/xen/privcmd.c b/drivers/xen/privcmd.c
deleted file mode 100644
index 0bbbccbb1f1..00000000000
--- a/drivers/xen/privcmd.c
+++ /dev/null
@@ -1,575 +0,0 @@
-/******************************************************************************
- * privcmd.c
- *
- * Interface to privileged domain-0 commands.
- *
- * Copyright (c) 2002-2004, K A Fraser, B Dragovic
- */
-#include <linux/kernel.h>
-#include <linux/module.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/highmem.h>
-#include <linux/pagemap.h>
-#include <linux/seq_file.h>
-#include <linux/miscdevice.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>
-#include <xen/balloon.h>
-#include "privcmd.h"
-MODULE_LICENSE("GPL");
-#define PRIV_VMA_LOCKED ((void *)1)
-#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,
-                        const 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, NULL);
-        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;
-        /* We only support privcmd_ioctl_mmap_batch for auto translated. */
-        if (xen_feature(XENFEAT_auto_translated_physmap))
-                return -ENOSYS;
-        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 index;
-        /* A tristate:
-         *      0 for no errors
-         *      1 if at least one error has happened (and no
-         *          -ENOENT errors have happened)
-         *      -ENOENT if at least 1 -ENOENT has happened.
-         */
-        int global_error;
-        /* An array for individual errors */
-        int *err;
-        /* User-space mfn array to store errors in the second pass for V1. */
-        xen_pfn_t __user *user_mfn;
-};
-/* auto translated dom0 note: if domU being created is PV, then mfn is
- * mfn(addr on bus). If it's auto xlated, then mfn is pfn (input to HAP).
- */
-static int mmap_batch_fn(void *data, void *state)
-{
-        xen_pfn_t *mfnp = data;
-        struct mmap_batch_state *st = state;
-        struct vm_area_struct *vma = st->vma;
-        struct page **pages = vma->vm_private_data;
-        struct page *cur_page = NULL;
-        int ret;
-        if (xen_feature(XENFEAT_auto_translated_physmap))
-                cur_page = pages[st->index++];
-        ret = xen_remap_domain_mfn_range(st->vma, st->va & PAGE_MASK, *mfnp, 1,
-                                         st->vma->vm_page_prot, st->domain,
-                                         &cur_page);
-        /* Store error code for second pass. */
-        *(st->err++) = ret;
-        /* And see if it affects the global_error. */
-        if (ret < 0) {
-                if (ret == -ENOENT)
-                        st->global_error = -ENOENT;
-                else {
-                        /* Record that at least one error has happened. */
-                        if (st->global_error == 0)
-                                st->global_error = 1;
-                }
-        }
-        st->va += PAGE_SIZE;
-        return 0;
-}
-static int mmap_return_errors_v1(void *data, void *state)
-{
-        xen_pfn_t *mfnp = data;
-        struct mmap_batch_state *st = state;
-        int err = *(st->err++);
-        /*
-         * V1 encodes the error codes in the 32bit top nibble of the
-         * mfn (with its known limitations vis-a-vis 64 bit callers).
-         */
-        *mfnp |= (err == -ENOENT) ?
-                                PRIVCMD_MMAPBATCH_PAGED_ERROR :
-                                PRIVCMD_MMAPBATCH_MFN_ERROR;
-        return __put_user(*mfnp, st->user_mfn++);
-}
-/* Allocate pfns that are then mapped with gmfns from foreign domid. Update
- * the vma with the page info to use later.
- * Returns: 0 if success, otherwise -errno
- */
-static int alloc_empty_pages(struct vm_area_struct *vma, int numpgs)
-{
-        int rc;
-        struct page **pages;
-        pages = kcalloc(numpgs, sizeof(pages[0]), GFP_KERNEL);
-        if (pages == NULL)
-                return -ENOMEM;
-        rc = alloc_xenballooned_pages(numpgs, pages, 0);
-        if (rc != 0) {
-                pr_warn("%s Could not alloc %d pfns rc:%d\n", __func__,
-                        numpgs, rc);
-                kfree(pages);
-                return -ENOMEM;
-        }
-        BUG_ON(vma->vm_private_data != PRIV_VMA_LOCKED);
-        vma->vm_private_data = pages;
-        return 0;
-}
-static struct vm_operations_struct privcmd_vm_ops;
-static long privcmd_ioctl_mmap_batch(void __user *udata, int version)
-{
-        int ret;
-        struct privcmd_mmapbatch_v2 m;
-        struct mm_struct *mm = current->mm;
-        struct vm_area_struct *vma;
-        unsigned long nr_pages;
-        LIST_HEAD(pagelist);
-        int *err_array = NULL;
-        struct mmap_batch_state state;
-        if (!xen_initial_domain())
-                return -EPERM;
-        switch (version) {
-        case 1:
-                if (copy_from_user(&m, udata, sizeof(struct privcmd_mmapbatch)))
-                        return -EFAULT;
-                /* Returns per-frame error in m.arr. */
-                m.err = NULL;
-                if (!access_ok(VERIFY_WRITE, m.arr, m.num * sizeof(*m.arr)))
-                        return -EFAULT;
-                break;
-        case 2:
-                if (copy_from_user(&m, udata, sizeof(struct privcmd_mmapbatch_v2)))
-                        return -EFAULT;
-                /* Returns per-frame error code in m.err. */
-                if (!access_ok(VERIFY_WRITE, m.err, m.num * (sizeof(*m.err))))
-                        return -EFAULT;
-                break;
-        default:
-                return -EINVAL;
-        }
-        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)
-                goto out;
-        if (list_empty(&pagelist)) {
-                ret = -EINVAL;
-                goto out;
-        }
-        err_array = kcalloc(m.num, sizeof(int), GFP_KERNEL);
-        if (err_array == NULL) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        down_write(&mm->mmap_sem);
-        vma = find_vma(mm, m.addr);
-        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);
-                ret = -EINVAL;
-                goto out;
-        }
-        if (xen_feature(XENFEAT_auto_translated_physmap)) {
-                ret = alloc_empty_pages(vma, m.num);
-                if (ret < 0) {
-                        up_write(&mm->mmap_sem);
-                        goto out;
-                }
-        }
-        state.domain        = m.dom;
-        state.vma           = vma;
-        state.va            = m.addr;
-        state.index         = 0;
-        state.global_error  = 0;
-        state.err           = err_array;
-        /* mmap_batch_fn guarantees ret == 0 */
-        BUG_ON(traverse_pages(m.num, sizeof(xen_pfn_t),
-                             &pagelist, mmap_batch_fn, &state));
-        up_write(&mm->mmap_sem);
-        if (version == 1) {
-                if (state.global_error) {
-                        /* Write back errors in second pass. */
-                        state.user_mfn = (xen_pfn_t *)m.arr;
-                        state.err      = err_array;
-                        ret = traverse_pages(m.num, sizeof(xen_pfn_t),
-                                             &pagelist, mmap_return_errors_v1, &state);
-                } else
-                        ret = 0;
-        } else if (version == 2) {
-                ret = __copy_to_user(m.err, err_array, m.num * sizeof(int));
-                if (ret)
-                        ret = -EFAULT;
-        }
-        /* If we have not had any EFAULT-like global errors then set the global
-         * error to -ENOENT if necessary. */
-        if ((ret == 0) && (state.global_error == -ENOENT))
-                ret = -ENOENT;
-out:
-        kfree(err_array);
-        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, 1);
-                break;
-        case IOCTL_PRIVCMD_MMAPBATCH_V2:
-                ret = privcmd_ioctl_mmap_batch(udata, 2);
-                break;
-        default:
-                ret = -EINVAL;
-                break;
-        }
-        return ret;
-}
-static void privcmd_close(struct vm_area_struct *vma)
-{
-        struct page **pages = vma->vm_private_data;
-        int numpgs = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
-        if (!xen_feature(XENFEAT_auto_translated_physmap || !numpgs || !pages))
-                return;
-        xen_unmap_domain_mfn_range(vma, numpgs, pages);
-        free_xenballooned_pages(numpgs, pages);
-        kfree(pages);
-}
-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 = {
-        .close = privcmd_close,
-        .fault = privcmd_fault
-};
-static int privcmd_mmap(struct file *file, struct vm_area_struct *vma)
-{
-        /* DONTCOPY is essential for Xen because copy_page_range doesn't know
-         * how to recreate these mappings */
-        vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTCOPY |
-                         VM_DONTEXPAND | VM_DONTDUMP;
-        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 !cmpxchg(&vma->vm_private_data, NULL, PRIV_VMA_LOCKED);
-}
-const struct file_operations xen_privcmd_fops = {
-        .owner = THIS_MODULE,
-        .unlocked_ioctl = privcmd_ioctl,
-        .mmap = privcmd_mmap,
-};
-EXPORT_SYMBOL_GPL(xen_privcmd_fops);
-static struct miscdevice privcmd_dev = {
-        .minor = MISC_DYNAMIC_MINOR,
-        .name = "xen/privcmd",
-        .fops = &xen_privcmd_fops,
-};
-static int __init privcmd_init(void)
-{
-        int err;
-        if (!xen_domain())
-                return -ENODEV;
-        err = misc_register(&privcmd_dev);
-        if (err != 0) {
-                printk(KERN_ERR "Could not register Xen privcmd device\n");
-                return err;
-        }
-        return 0;
-}
-static void __exit privcmd_exit(void)
-{
-        misc_deregister(&privcmd_dev);
-}
-module_init(privcmd_init);
-module_exit(privcmd_exit);
diff --git a/drivers/xen/privcmd.h b/drivers/xen/privcmd.h
deleted file mode 100644
index 14facaeed36..00000000000
--- a/drivers/xen/privcmd.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#include <linux/fs.h>
-extern const struct file_operations xen_privcmd_fops;
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index af47e759446..84f317e0cc2 100644
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -35,11 +35,9 @@
 #include <linux/bootmem.h>
 #include <linux/dma-mapping.h>
-#include <linux/export.h>
 #include <xen/swiotlb-xen.h>
 #include <xen/page.h>
 #include <xen/xen-ops.h>
-#include <xen/hvc-console.h>
 /*
 * Used to do a quick range check in swiotlb_tbl_unmap_single and
 * swiotlb_tbl_sync_single_*, to see if the memory was in fact allocated by this
@@ -52,7 +50,7 @@ static unsigned long xen_io_tlb_nslabs;
 * Quick lookup value of the bus address of the IOTLB.
 */
-static u64 start_dma_addr;
+u64 start_dma_addr;
 static dma_addr_t xen_phys_to_bus(phys_addr_t paddr)
 {
@@ -144,74 +142,30 @@ xen_swiotlb_fixup(void *buf, size_t size, unsigned long nslabs)
        } while (i < nslabs);
        return 0;
 }
-static unsigned long xen_set_nslabs(unsigned long nr_tbl)
+void __init xen_swiotlb_init(int verbose)
 {
-        if (!nr_tbl) {
+        unsigned long bytes;
+        int rc;
+        unsigned long nr_tbl;
+        nr_tbl = swioltb_nr_tbl();
+        if (nr_tbl)
+                xen_io_tlb_nslabs = nr_tbl;
+        else {
                xen_io_tlb_nslabs = (64 * 1024 * 1024 >> IO_TLB_SHIFT);
                xen_io_tlb_nslabs = ALIGN(xen_io_tlb_nslabs, IO_TLB_SEGSIZE);
-        } else
+        }
-                xen_io_tlb_nslabs = nr_tbl;
-        return xen_io_tlb_nslabs << IO_TLB_SHIFT;
-}
-enum xen_swiotlb_err {
+        bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
-        XEN_SWIOTLB_UNKNOWN = 0,
-        XEN_SWIOTLB_ENOMEM,
-        XEN_SWIOTLB_EFIXUP
-};
-static const char *xen_swiotlb_error(enum xen_swiotlb_err err)
-{
-        switch (err) {
-        case XEN_SWIOTLB_ENOMEM:
-                return "Cannot allocate Xen-SWIOTLB buffer\n";
-        case XEN_SWIOTLB_EFIXUP:
-                return "Failed to get contiguous memory for DMA from Xen!\n"\
-                    "You either: don't have the permissions, do not have"\
-                    " enough free memory under 4GB, or the hypervisor memory"\
-                    " is too fragmented!";
-        default:
-                break;
-        }
-        return "";
-}
-int __ref xen_swiotlb_init(int verbose, bool early)
-{
-        unsigned long bytes, order;
-        int rc = -ENOMEM;
-        enum xen_swiotlb_err m_ret = XEN_SWIOTLB_UNKNOWN;
-        unsigned int repeat = 3;
-        xen_io_tlb_nslabs = swiotlb_nr_tbl();
-retry:
-        bytes = xen_set_nslabs(xen_io_tlb_nslabs);
-        order = get_order(xen_io_tlb_nslabs << IO_TLB_SHIFT);
        /*
         * Get IO TLB memory from any location.
         */
-        if (early)
+        xen_io_tlb_start = alloc_bootmem(bytes);
-                xen_io_tlb_start = alloc_bootmem_pages(PAGE_ALIGN(bytes));
+        if (!xen_io_tlb_start)
-        else {
+                panic("Cannot allocate SWIOTLB buffer");
-#define SLABS_PER_PAGE (1 << (PAGE_SHIFT - IO_TLB_SHIFT))
-#define IO_TLB_MIN_SLABS ((1<<20) >> IO_TLB_SHIFT)
-                while ((SLABS_PER_PAGE << order) > IO_TLB_MIN_SLABS) {
-                        xen_io_tlb_start = (void *)__get_free_pages(__GFP_NOWARN, order);
-                        if (xen_io_tlb_start)
-                                break;
-                        order--;
-                }
-                if (order != get_order(bytes)) {
-                        pr_warn("Warning: only able to allocate %ld MB "
-                                "for software IO TLB\n", (PAGE_SIZE << order) >> 20);
-                        xen_io_tlb_nslabs = SLABS_PER_PAGE << order;
-                        bytes = xen_io_tlb_nslabs << IO_TLB_SHIFT;
-                }
-        }
-        if (!xen_io_tlb_start) {
-                m_ret = XEN_SWIOTLB_ENOMEM;
-                goto error;
-        }
        xen_io_tlb_end = xen_io_tlb_start + bytes;
        /*
         * And replace that memory with pages under 4GB.
@@ -219,49 +173,27 @@ retry:
        rc = xen_swiotlb_fixup(xen_io_tlb_start,
                               bytes,
                               xen_io_tlb_nslabs);
-        if (rc) {
+        if (rc)
-                if (early)
-                        free_bootmem(__pa(xen_io_tlb_start), PAGE_ALIGN(bytes));
-                else {
-                        free_pages((unsigned long)xen_io_tlb_start, order);
-                        xen_io_tlb_start = NULL;
-                }
-                m_ret = XEN_SWIOTLB_EFIXUP;
                goto error;
-        }
        start_dma_addr = xen_virt_to_bus(xen_io_tlb_start);
-        if (early) {
+        swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs, verbose);
-                swiotlb_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs, verbose);
-                rc = 0;
+        return;
-        } else
-                rc = swiotlb_late_init_with_tbl(xen_io_tlb_start, xen_io_tlb_nslabs);
-        return rc;
 error:
-        if (repeat--) {
+        panic("DMA(%d): Failed to exchange pages allocated for DMA with Xen! "\
-                xen_io_tlb_nslabs = max(1024UL, /* Min is 2MB */
+              "We either don't have the permission or you do not have enough"\
-                                        (xen_io_tlb_nslabs >> 1));
+              "free memory under 4GB!\n", rc);
-                printk(KERN_INFO "Xen-SWIOTLB: Lowering to %luMB\n",
-                      (xen_io_tlb_nslabs << IO_TLB_SHIFT) >> 20);
-                goto retry;
-        }
-        pr_err("%s (rc:%d)", xen_swiotlb_error(m_ret), rc);
-        if (early)
-                panic("%s (rc:%d)", xen_swiotlb_error(m_ret), rc);
-        else
-                free_pages((unsigned long)xen_io_tlb_start, order);
-        return rc;
 }
 void *
 xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
-                           dma_addr_t *dma_handle, gfp_t flags,
+                           dma_addr_t *dma_handle, gfp_t flags)
-                           struct dma_attrs *attrs)
 {
        void *ret;
        int order = get_order(size);
        u64 dma_mask = DMA_BIT_MASK(32);
        unsigned long vstart;
-        phys_addr_t phys;
-        dma_addr_t dev_addr;
        /*
        * Ignore region specifiers - the kernel's ideas of
@@ -277,50 +209,32 @@ xen_swiotlb_alloc_coherent(struct device *hwdev, size_t size,
        vstart = __get_free_pages(flags, order);
        ret = (void *)vstart;
-        if (!ret)
-                return ret;
        if (hwdev && hwdev->coherent_dma_mask)
                dma_mask = dma_alloc_coherent_mask(hwdev, flags);
-        phys = virt_to_phys(ret);
+        if (ret) {
-        dev_addr = xen_phys_to_bus(phys);
-        if (((dev_addr + size - 1 <= dma_mask)) &&
-            !range_straddles_page_boundary(phys, size))
-                *dma_handle = dev_addr;
-        else {
                if (xen_create_contiguous_region(vstart, order,
                                                 fls64(dma_mask)) != 0) {
                        free_pages(vstart, order);
                        return NULL;
                }
+                memset(ret, 0, size);
                *dma_handle = virt_to_machine(ret).maddr;
        }
-        memset(ret, 0, size);
        return ret;
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_alloc_coherent);
 void
 xen_swiotlb_free_coherent(struct device *hwdev, size_t size, void *vaddr,
-                          dma_addr_t dev_addr, struct dma_attrs *attrs)
+                          dma_addr_t dev_addr)
 {
        int order = get_order(size);
-        phys_addr_t phys;
-        u64 dma_mask = DMA_BIT_MASK(32);
        if (dma_release_from_coherent(hwdev, order, vaddr))
                return;
-        if (hwdev && hwdev->coherent_dma_mask)
+        xen_destroy_contiguous_region((unsigned long)vaddr, order);
-                dma_mask = hwdev->coherent_dma_mask;
-        phys = virt_to_phys(vaddr);
-        if (((dev_addr + size - 1 > dma_mask)) ||
-            range_straddles_page_boundary(phys, size))
-                xen_destroy_contiguous_region((unsigned long)vaddr, order);
        free_pages((unsigned long)vaddr, order);
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_free_coherent);
@@ -338,8 +252,9 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
                                enum dma_data_direction dir,
                                struct dma_attrs *attrs)
 {
-        phys_addr_t map, phys = page_to_phys(page) + offset;
+        phys_addr_t phys = page_to_phys(page) + offset;
        dma_addr_t dev_addr = xen_phys_to_bus(phys);
+        void *map;
        BUG_ON(dir == DMA_NONE);
        /*
@@ -355,10 +270,10 @@ dma_addr_t xen_swiotlb_map_page(struct device *dev, struct page *page,
         * Oh well, have to allocate and map a bounce buffer.
         */
        map = swiotlb_tbl_map_single(dev, start_dma_addr, phys, size, dir);
-        if (map == SWIOTLB_MAP_ERROR)
+        if (!map)
                return DMA_ERROR_CODE;
-        dev_addr = xen_phys_to_bus(map);
+        dev_addr = xen_virt_to_bus(map);
        /*
         * Ensure that the address returned is DMA'ble
@@ -388,7 +303,7 @@ static void xen_unmap_single(struct device *hwdev, dma_addr_t dev_addr,
        /* NOTE: We use dev_addr here, not paddr! */
        if (is_xen_swiotlb_buffer(dev_addr)) {
-                swiotlb_tbl_unmap_single(hwdev, paddr, size, dir);
+                swiotlb_tbl_unmap_single(hwdev, phys_to_virt(paddr), size, dir);
                return;
        }
@@ -433,7 +348,8 @@ xen_swiotlb_sync_single(struct device *hwdev, dma_addr_t dev_addr,
        /* NOTE: We use dev_addr here, not paddr! */
        if (is_xen_swiotlb_buffer(dev_addr)) {
-                swiotlb_tbl_sync_single(hwdev, paddr, size, dir, target);
+                swiotlb_tbl_sync_single(hwdev, phys_to_virt(paddr), size, dir,
+                                       target);
                return;
        }
@@ -492,12 +408,11 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                if (swiotlb_force ||
                    !dma_capable(hwdev, dev_addr, sg->length) ||
                    range_straddles_page_boundary(paddr, sg->length)) {
-                        phys_addr_t map = swiotlb_tbl_map_single(hwdev,
+                        void *map = swiotlb_tbl_map_single(hwdev,
-                                                                 start_dma_addr,
+                                                           start_dma_addr,
-                                                                 sg_phys(sg),
+                                                           sg_phys(sg),
-                                                                 sg->length,
+                                                           sg->length, dir);
-                                                                 dir);
+                        if (!map) {
-                        if (map == SWIOTLB_MAP_ERROR) {
                                /* Don't panic here, we expect map_sg users
                                   to do proper error handling. */
                                xen_swiotlb_unmap_sg_attrs(hwdev, sgl, i, dir,
@@ -505,7 +420,7 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
                                sgl[0].dma_length = 0;
                                return DMA_ERROR_CODE;
                        }
-                        sg->dma_address = xen_phys_to_bus(map);
+                        sg->dma_address = xen_virt_to_bus(map);
                } else
                        sg->dma_address = dev_addr;
                sg->dma_length = sg->length;
@@ -514,6 +429,14 @@ xen_swiotlb_map_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg_attrs);
+int
+xen_swiotlb_map_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
+                   enum dma_data_direction dir)
+{
+        return xen_swiotlb_map_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_map_sg);
 /*
 * Unmap a set of streaming mode DMA translations.  Again, cpu read rules
 * concerning calls here are the same as for swiotlb_unmap_page() above.
@@ -534,6 +457,14 @@ xen_swiotlb_unmap_sg_attrs(struct device *hwdev, struct scatterlist *sgl,
 }
 EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg_attrs);
+void
+xen_swiotlb_unmap_sg(struct device *hwdev, struct scatterlist *sgl, int nelems,
+                     enum dma_data_direction dir)
+{
+        return xen_swiotlb_unmap_sg_attrs(hwdev, sgl, nelems, dir, NULL);
+}
+EXPORT_SYMBOL_GPL(xen_swiotlb_unmap_sg);
 /*
 * Make physical memory consistent for a set of streaming mode DMA translations
 * after a transfer.
diff --git a/drivers/xen/sys-hypervisor.c b/drivers/xen/sys-hypervisor.c
index 96453f8a85c..1e0fe01eb67 100644
--- a/drivers/xen/sys-hypervisor.c
+++ b/drivers/xen/sys-hypervisor.c
@@ -11,7 +11,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/kobject.h>
-#include <linux/err.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
@@ -98,7 +97,7 @@ static struct attribute *version_attrs[] = {
        NULL
 };
-static const struct attribute_group version_group = {
+static struct attribute_group version_group = {
        .name = "version",
        .attrs = version_attrs,
 };
@@ -115,7 +114,7 @@ static void xen_sysfs_version_destroy(void)
 /* UUID */
-static ssize_t uuid_show_fallback(struct hyp_sysfs_attr *attr, char *buffer)
+static ssize_t uuid_show(struct hyp_sysfs_attr *attr, char *buffer)
 {
        char *vm, *val;
        int ret;
@@ -136,17 +135,6 @@ static ssize_t uuid_show_fallback(struct hyp_sysfs_attr *attr, char *buffer)
        return ret;
 }
-static ssize_t uuid_show(struct hyp_sysfs_attr *attr, char *buffer)
-{
-        xen_domain_handle_t uuid;
-        int ret;
-        ret = HYPERVISOR_xen_version(XENVER_guest_handle, uuid);
-        if (ret)
-                return uuid_show_fallback(attr, buffer);
-        ret = sprintf(buffer, "%pU\n", uuid);
-        return ret;
-}
 HYPERVISOR_ATTR_RO(uuid);
 static int __init xen_sysfs_uuid_init(void)
@@ -222,7 +210,7 @@ static struct attribute *xen_compile_attrs[] = {
        NULL
 };
-static const struct attribute_group xen_compilation_group = {
+static struct attribute_group xen_compilation_group = {
        .name = "compilation",
        .attrs = xen_compile_attrs,
 };
@@ -285,8 +273,7 @@ static ssize_t virtual_start_show(struct hyp_sysfs_attr *attr, char *buffer)
                ret = HYPERVISOR_xen_version(XENVER_platform_parameters,
                                             parms);
                if (!ret)
-                        ret = sprintf(buffer, "%"PRI_xen_ulong"\n",
+                        ret = sprintf(buffer, "%lx\n", parms->virt_start);
-                                      parms->virt_start);
                kfree(parms);
        }
@@ -353,7 +340,7 @@ static struct attribute *xen_properties_attrs[] = {
        NULL
 };
-static const struct attribute_group xen_properties_group = {
+static struct attribute_group xen_properties_group = {
        .name = "properties",
        .attrs = xen_properties_attrs,
 };
diff --git a/drivers/xen/tmem.c b/drivers/xen/tmem.c
index 144564e5eb2..d369965e8f8 100644
--- a/drivers/xen/tmem.c
+++ b/drivers/xen/tmem.c
@@ -9,6 +9,7 @@
 #include <linux/types.h>
 #include <linux/init.h>
 #include <linux/pagemap.h>
+#include <linux/module.h>
 #include <linux/cleancache.h>
 /* temporary ifdef until include/linux/frontswap.h is upstream */
@@ -21,7 +22,6 @@
 #include <asm/xen/hypercall.h>
 #include <asm/xen/page.h>
 #include <asm/xen/hypervisor.h>
-#include <xen/tmem.h>
 #define TMEM_CONTROL               0
 #define TMEM_NEW_POOL              1
@@ -128,13 +128,15 @@ static int xen_tmem_flush_object(u32 pool_id, struct tmem_oid oid)
        return xen_tmem_op(TMEM_FLUSH_OBJECT, pool_id, oid, 0, 0, 0, 0, 0);
 }
-bool __read_mostly tmem_enabled = false;
+int tmem_enabled __read_mostly;
+EXPORT_SYMBOL(tmem_enabled);
 static int __init enable_tmem(char *s)
 {
-        tmem_enabled = true;
+        tmem_enabled = 1;
        return 1;
 }
 __setup("tmem", enable_tmem);
 #ifdef CONFIG_CLEANCACHE
@@ -227,21 +229,22 @@ static int tmem_cleancache_init_shared_fs(char *uuid, size_t pagesize)
        return xen_tmem_new_pool(shared_uuid, TMEM_POOL_SHARED, pagesize);
 }
-static bool __initdata use_cleancache = true;
+static int use_cleancache = 1;
 static int __init no_cleancache(char *s)
 {
-        use_cleancache = false;
+        use_cleancache = 0;
        return 1;
 }
 __setup("nocleancache", no_cleancache);
-static struct cleancache_ops __initdata tmem_cleancache_ops = {
+static struct cleancache_ops tmem_cleancache_ops = {
        .put_page = tmem_cleancache_put_page,
        .get_page = tmem_cleancache_get_page,
-        .invalidate_page = tmem_cleancache_flush_page,
+        .flush_page = tmem_cleancache_flush_page,
-        .invalidate_inode = tmem_cleancache_flush_inode,
+        .flush_inode = tmem_cleancache_flush_inode,
-        .invalidate_fs = tmem_cleancache_flush_fs,
+        .flush_fs = tmem_cleancache_flush_fs,
        .init_shared_fs = tmem_cleancache_init_shared_fs,
        .init_fs = tmem_cleancache_init_fs
 };
@@ -270,7 +273,7 @@ static inline struct tmem_oid oswiz(unsigned type, u32 ind)
 }
 /* returns 0 if the page was successfully put into frontswap, -1 if not */
-static int tmem_frontswap_store(unsigned type, pgoff_t offset,
+static int tmem_frontswap_put_page(unsigned type, pgoff_t offset,
                                   struct page *page)
 {
        u64 ind64 = (u64)offset;
@@ -296,7 +299,7 @@ static int tmem_frontswap_store(unsigned type, pgoff_t offset,
 * returns 0 if the page was successfully gotten from frontswap, -1 if
 * was not present (should never happen!)
 */
-static int tmem_frontswap_load(unsigned type, pgoff_t offset,
+static int tmem_frontswap_get_page(unsigned type, pgoff_t offset,
                                   struct page *page)
 {
        u64 ind64 = (u64)offset;
@@ -353,20 +356,21 @@ static void tmem_frontswap_init(unsigned ignored)
                    xen_tmem_new_pool(private, TMEM_POOL_PERSIST, PAGE_SIZE);
 }
-static bool __initdata use_frontswap = true;
+static int __initdata use_frontswap = 1;
 static int __init no_frontswap(char *s)
 {
-        use_frontswap = false;
+        use_frontswap = 0;
        return 1;
 }
 __setup("nofrontswap", no_frontswap);
-static struct frontswap_ops __initdata tmem_frontswap_ops = {
+static struct frontswap_ops tmem_frontswap_ops = {
-        .store = tmem_frontswap_store,
+        .put_page = tmem_frontswap_put_page,
-        .load = tmem_frontswap_load,
+        .get_page = tmem_frontswap_get_page,
-        .invalidate_page = tmem_frontswap_flush_page,
+        .flush_page = tmem_frontswap_flush_page,
-        .invalidate_area = tmem_frontswap_flush_area,
+        .flush_area = tmem_frontswap_flush_area,
        .init = tmem_frontswap_init
 };
 #endif
diff --git a/drivers/xen/xen-acpi-pad.c b/drivers/xen/xen-acpi-pad.c
deleted file mode 100644
index da39191e727..00000000000
--- a/drivers/xen/xen-acpi-pad.c
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * xen-acpi-pad.c - Xen pad interface
- *
- * Copyright (c) 2012, Intel Corporation.
- *    Author: Liu, Jinsong <jinsong.liu@intel.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- */
-#include <linux/kernel.h>
-#include <linux/types.h>
-#include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
-#include <asm/xen/hypercall.h>
-#include <xen/interface/version.h>
-#include <xen/xen-ops.h>
-#define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"
-#define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
-#define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
-static DEFINE_MUTEX(xen_cpu_lock);
-static int xen_acpi_pad_idle_cpus(unsigned int idle_nums)
-{
-        struct xen_platform_op op;
-        op.cmd = XENPF_core_parking;
-        op.u.core_parking.type = XEN_CORE_PARKING_SET;
-        op.u.core_parking.idle_nums = idle_nums;
-        return HYPERVISOR_dom0_op(&op);
-}
-static int xen_acpi_pad_idle_cpus_num(void)
-{
-        struct xen_platform_op op;
-        op.cmd = XENPF_core_parking;
-        op.u.core_parking.type = XEN_CORE_PARKING_GET;
-        return HYPERVISOR_dom0_op(&op)
-               ?: op.u.core_parking.idle_nums;
-}
-/*
- * Query firmware how many CPUs should be idle
- * return -1 on failure
- */
-static int acpi_pad_pur(acpi_handle handle)
-{
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-        union acpi_object *package;
-        int num = -1;
-        if (ACPI_FAILURE(acpi_evaluate_object(handle, "_PUR", NULL, &buffer)))
-                return num;
-        if (!buffer.length || !buffer.pointer)
-                return num;
-        package = buffer.pointer;
-        if (package->type == ACPI_TYPE_PACKAGE &&
-                package->package.count == 2 &&
-                package->package.elements[0].integer.value == 1) /* rev 1 */
-                num = package->package.elements[1].integer.value;
-        kfree(buffer.pointer);
-        return num;
-}
-/* Notify firmware how many CPUs are idle */
-static void acpi_pad_ost(acpi_handle handle, int stat,
-        uint32_t idle_nums)
-{
-        union acpi_object params[3] = {
-                {.type = ACPI_TYPE_INTEGER,},
-                {.type = ACPI_TYPE_INTEGER,},
-                {.type = ACPI_TYPE_BUFFER,},
-        };
-        struct acpi_object_list arg_list = {3, params};
-        params[0].integer.value = ACPI_PROCESSOR_AGGREGATOR_NOTIFY;
-        params[1].integer.value =  stat;
-        params[2].buffer.length = 4;
-        params[2].buffer.pointer = (void *)&idle_nums;
-        acpi_evaluate_object(handle, "_OST", &arg_list, NULL);
-}
-static void acpi_pad_handle_notify(acpi_handle handle)
-{
-        int idle_nums;
-        mutex_lock(&xen_cpu_lock);
-        idle_nums = acpi_pad_pur(handle);
-        if (idle_nums < 0) {
-                mutex_unlock(&xen_cpu_lock);
-                return;
-        }
-        idle_nums = xen_acpi_pad_idle_cpus(idle_nums)
-                    ?: xen_acpi_pad_idle_cpus_num();
-        if (idle_nums >= 0)
-                acpi_pad_ost(handle, 0, idle_nums);
-        mutex_unlock(&xen_cpu_lock);
-}
-static void acpi_pad_notify(acpi_handle handle, u32 event,
-        void *data)
-{
-        switch (event) {
-        case ACPI_PROCESSOR_AGGREGATOR_NOTIFY:
-                acpi_pad_handle_notify(handle);
-                break;
-        default:
-                pr_warn("Unsupported event [0x%x]\n", event);
-                break;
-        }
-}
-static int acpi_pad_add(struct acpi_device *device)
-{
-        acpi_status status;
-        strcpy(acpi_device_name(device), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME);
-        strcpy(acpi_device_class(device), ACPI_PROCESSOR_AGGREGATOR_CLASS);
-        status = acpi_install_notify_handler(device->handle,
-                ACPI_DEVICE_NOTIFY, acpi_pad_notify, device);
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-        return 0;
-}
-static int acpi_pad_remove(struct acpi_device *device,
-        int type)
-{
-        mutex_lock(&xen_cpu_lock);
-        xen_acpi_pad_idle_cpus(0);
-        mutex_unlock(&xen_cpu_lock);
-        acpi_remove_notify_handler(device->handle,
-                ACPI_DEVICE_NOTIFY, acpi_pad_notify);
-        return 0;
-}
-static const struct acpi_device_id pad_device_ids[] = {
-        {"ACPI000C", 0},
-        {"", 0},
-};
-static struct acpi_driver acpi_pad_driver = {
-        .name = "processor_aggregator",
-        .class = ACPI_PROCESSOR_AGGREGATOR_CLASS,
-        .ids = pad_device_ids,
-        .ops = {
-                .add = acpi_pad_add,
-                .remove = acpi_pad_remove,
-        },
-};
-static int __init xen_acpi_pad_init(void)
-{
-        /* Only DOM0 is responsible for Xen acpi pad */
-        if (!xen_initial_domain())
-                return -ENODEV;
-        /* Only Xen4.2 or later support Xen acpi pad */
-        if (!xen_running_on_version_or_later(4, 2))
-                return -ENODEV;
-        return acpi_bus_register_driver(&acpi_pad_driver);
-}
-subsys_initcall(xen_acpi_pad_init);
diff --git a/drivers/xen/xen-acpi-processor.c b/drivers/xen/xen-acpi-processor.c
deleted file mode 100644
index 316df65163c..00000000000
--- a/drivers/xen/xen-acpi-processor.c
+++ /dev/null
@@ -1,568 +0,0 @@
-/*
- * Copyright 2012 by Oracle Inc
- * Author: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
- *
- * This code borrows ideas from https://lkml.org/lkml/2011/11/30/249
- * so many thanks go to Kevin Tian <kevin.tian@intel.com>
- * and Yu Ke <ke.yu@intel.com>.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- */
-#include <linux/cpumask.h>
-#include <linux/cpufreq.h>
-#include <linux/freezer.h>
-#include <linux/kernel.h>
-#include <linux/kthread.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <acpi/acpi_bus.h>
-#include <acpi/acpi_drivers.h>
-#include <acpi/processor.h>
-#include <xen/xen.h>
-#include <xen/interface/platform.h>
-#include <asm/xen/hypercall.h>
-#define DRV_NAME "xen-acpi-processor: "
-static int no_hypercall;
-MODULE_PARM_DESC(off, "Inhibit the hypercall.");
-module_param_named(off, no_hypercall, int, 0400);
-/*
- * Note: Do not convert the acpi_id* below to cpumask_var_t or use cpumask_bit
- * - as those shrink to nr_cpu_bits (which is dependent on possible_cpu), which
- * can be less than what we want to put in. Instead use the 'nr_acpi_bits'
- * which is dynamically computed based on the MADT or x2APIC table.
- */
-static unsigned int nr_acpi_bits;
-/* Mutex to protect the acpi_ids_done - for CPU hotplug use. */
-static DEFINE_MUTEX(acpi_ids_mutex);
-/* Which ACPI ID we have processed from 'struct acpi_processor'. */
-static unsigned long *acpi_ids_done;
-/* Which ACPI ID exist in the SSDT/DSDT processor definitions. */
-static unsigned long __initdata *acpi_id_present;
-/* And if there is an _CST definition (or a PBLK) for the ACPI IDs */
-static unsigned long __initdata *acpi_id_cst_present;
-static int push_cxx_to_hypervisor(struct acpi_processor *_pr)
-{
-        struct xen_platform_op op = {
-                .cmd                    = XENPF_set_processor_pminfo,
-                .interface_version      = XENPF_INTERFACE_VERSION,
-                .u.set_pminfo.id        = _pr->acpi_id,
-                .u.set_pminfo.type      = XEN_PM_CX,
-        };
-        struct xen_processor_cx *dst_cx, *dst_cx_states = NULL;
-        struct acpi_processor_cx *cx;
-        unsigned int i, ok;
-        int ret = 0;
-        dst_cx_states = kcalloc(_pr->power.count,
-                                sizeof(struct xen_processor_cx), GFP_KERNEL);
-        if (!dst_cx_states)
-                return -ENOMEM;
-        for (ok = 0, i = 1; i <= _pr->power.count; i++) {
-                cx = &_pr->power.states[i];
-                if (!cx->valid)
-                        continue;
-                dst_cx = &(dst_cx_states[ok++]);
-                dst_cx->reg.space_id = ACPI_ADR_SPACE_SYSTEM_IO;
-                if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
-                        dst_cx->reg.bit_width = 8;
-                        dst_cx->reg.bit_offset = 0;
-                        dst_cx->reg.access_size = 1;
-                } else {
-                        dst_cx->reg.space_id = ACPI_ADR_SPACE_FIXED_HARDWARE;
-                        if (cx->entry_method == ACPI_CSTATE_FFH) {
-                                /* NATIVE_CSTATE_BEYOND_HALT */
-                                dst_cx->reg.bit_offset = 2;
-                                dst_cx->reg.bit_width = 1; /* VENDOR_INTEL */
-                        }
-                        dst_cx->reg.access_size = 0;
-                }
-                dst_cx->reg.address = cx->address;
-                dst_cx->type = cx->type;
-                dst_cx->latency = cx->latency;
-                dst_cx->dpcnt = 0;
-                set_xen_guest_handle(dst_cx->dp, NULL);
-        }
-        if (!ok) {
-                pr_debug(DRV_NAME "No _Cx for ACPI CPU %u\n", _pr->acpi_id);
-                kfree(dst_cx_states);
-                return -EINVAL;
-        }
-        op.u.set_pminfo.power.count = ok;
-        op.u.set_pminfo.power.flags.bm_control = _pr->flags.bm_control;
-        op.u.set_pminfo.power.flags.bm_check = _pr->flags.bm_check;
-        op.u.set_pminfo.power.flags.has_cst = _pr->flags.has_cst;
-        op.u.set_pminfo.power.flags.power_setup_done =
-                _pr->flags.power_setup_done;
-        set_xen_guest_handle(op.u.set_pminfo.power.states, dst_cx_states);
-        if (!no_hypercall)
-                ret = HYPERVISOR_dom0_op(&op);
-        if (!ret) {
-                pr_debug("ACPI CPU%u - C-states uploaded.\n", _pr->acpi_id);
-                for (i = 1; i <= _pr->power.count; i++) {
-                        cx = &_pr->power.states[i];
-                        if (!cx->valid)
-                                continue;
-                        pr_debug("     C%d: %s %d uS\n",
-                                 cx->type, cx->desc, (u32)cx->latency);
-                }
-        } else if (ret != -EINVAL)
-                /* EINVAL means the ACPI ID is incorrect - meaning the ACPI
-                 * table is referencing a non-existing CPU - which can happen
-                 * with broken ACPI tables. */
-                pr_err(DRV_NAME "(CX): Hypervisor error (%d) for ACPI CPU%u\n",
-                       ret, _pr->acpi_id);
-        kfree(dst_cx_states);
-        return ret;
-}
-static struct xen_processor_px *
-xen_copy_pss_data(struct acpi_processor *_pr,
-                  struct xen_processor_performance *dst_perf)
-{
-        struct xen_processor_px *dst_states = NULL;
-        unsigned int i;
-        BUILD_BUG_ON(sizeof(struct xen_processor_px) !=
-                     sizeof(struct acpi_processor_px));
-        dst_states = kcalloc(_pr->performance->state_count,
-                             sizeof(struct xen_processor_px), GFP_KERNEL);
-        if (!dst_states)
-                return ERR_PTR(-ENOMEM);
-        dst_perf->state_count = _pr->performance->state_count;
-        for (i = 0; i < _pr->performance->state_count; i++) {
-                /* Fortunatly for us, they are both the same size */
-                memcpy(&(dst_states[i]), &(_pr->performance->states[i]),
-                       sizeof(struct acpi_processor_px));
-        }
-        return dst_states;
-}
-static int xen_copy_psd_data(struct acpi_processor *_pr,
-                             struct xen_processor_performance *dst)
-{
-        struct acpi_psd_package *pdomain;
-        BUILD_BUG_ON(sizeof(struct xen_psd_package) !=
-                     sizeof(struct acpi_psd_package));
-        /* This information is enumerated only if acpi_processor_preregister_performance
-         * has been called.
-         */
-        dst->shared_type = _pr->performance->shared_type;
-        pdomain = &(_pr->performance->domain_info);
-        /* 'acpi_processor_preregister_performance' does not parse if the
-         * num_processors <= 1, but Xen still requires it. Do it manually here.
-         */
-        if (pdomain->num_processors <= 1) {
-                if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ALL)
-                        dst->shared_type = CPUFREQ_SHARED_TYPE_ALL;
-                else if (pdomain->coord_type == DOMAIN_COORD_TYPE_HW_ALL)
-                        dst->shared_type = CPUFREQ_SHARED_TYPE_HW;
-                else if (pdomain->coord_type == DOMAIN_COORD_TYPE_SW_ANY)
-                        dst->shared_type = CPUFREQ_SHARED_TYPE_ANY;
-        }
-        memcpy(&(dst->domain_info), pdomain, sizeof(struct acpi_psd_package));
-        return 0;
-}
-static int xen_copy_pct_data(struct acpi_pct_register *pct,
-                             struct xen_pct_register *dst_pct)
-{
-        /* It would be nice if you could just do 'memcpy(pct, dst_pct') but
-         * sadly the Xen structure did not have the proper padding so the
-         * descriptor field takes two (dst_pct) bytes instead of one (pct).
-         */
-        dst_pct->descriptor = pct->descriptor;
-        dst_pct->length = pct->length;
-        dst_pct->space_id = pct->space_id;
-        dst_pct->bit_width = pct->bit_width;
-        dst_pct->bit_offset = pct->bit_offset;
-        dst_pct->reserved = pct->reserved;
-        dst_pct->address = pct->address;
-        return 0;
-}
-static int push_pxx_to_hypervisor(struct acpi_processor *_pr)
-{
-        int ret = 0;
-        struct xen_platform_op op = {
-                .cmd                    = XENPF_set_processor_pminfo,
-                .interface_version      = XENPF_INTERFACE_VERSION,
-                .u.set_pminfo.id        = _pr->acpi_id,
-                .u.set_pminfo.type      = XEN_PM_PX,
-        };
-        struct xen_processor_performance *dst_perf;
-        struct xen_processor_px *dst_states = NULL;
-        dst_perf = &op.u.set_pminfo.perf;
-        dst_perf->platform_limit = _pr->performance_platform_limit;
-        dst_perf->flags |= XEN_PX_PPC;
-        xen_copy_pct_data(&(_pr->performance->control_register),
-                          &dst_perf->control_register);
-        xen_copy_pct_data(&(_pr->performance->status_register),
-                          &dst_perf->status_register);
-        dst_perf->flags |= XEN_PX_PCT;
-        dst_states = xen_copy_pss_data(_pr, dst_perf);
-        if (!IS_ERR_OR_NULL(dst_states)) {
-                set_xen_guest_handle(dst_perf->states, dst_states);
-                dst_perf->flags |= XEN_PX_PSS;
-        }
-        if (!xen_copy_psd_data(_pr, dst_perf))
-                dst_perf->flags |= XEN_PX_PSD;
-        if (dst_perf->flags != (XEN_PX_PSD | XEN_PX_PSS | XEN_PX_PCT | XEN_PX_PPC)) {
-                pr_warn(DRV_NAME "ACPI CPU%u missing some P-state data (%x), skipping.\n",
-                        _pr->acpi_id, dst_perf->flags);
-                ret = -ENODEV;
-                goto err_free;
-        }
-        if (!no_hypercall)
-                ret = HYPERVISOR_dom0_op(&op);
-        if (!ret) {
-                struct acpi_processor_performance *perf;
-                unsigned int i;
-                perf = _pr->performance;
-                pr_debug("ACPI CPU%u - P-states uploaded.\n", _pr->acpi_id);
-                for (i = 0; i < perf->state_count; i++) {
-                        pr_debug("     %cP%d: %d MHz, %d mW, %d uS\n",
-                        (i == perf->state ? '*' : ' '), i,
-                        (u32) perf->states[i].core_frequency,
-                        (u32) perf->states[i].power,
-                        (u32) perf->states[i].transition_latency);
-                }
-        } else if (ret != -EINVAL)
-                /* EINVAL means the ACPI ID is incorrect - meaning the ACPI
-                 * table is referencing a non-existing CPU - which can happen
-                 * with broken ACPI tables. */
-                pr_warn(DRV_NAME "(_PXX): Hypervisor error (%d) for ACPI CPU%u\n",
-                       ret, _pr->acpi_id);
-err_free:
-        if (!IS_ERR_OR_NULL(dst_states))
-                kfree(dst_states);
-        return ret;
-}
-static int upload_pm_data(struct acpi_processor *_pr)
-{
-        int err = 0;
-        mutex_lock(&acpi_ids_mutex);
-        if (__test_and_set_bit(_pr->acpi_id, acpi_ids_done)) {
-                mutex_unlock(&acpi_ids_mutex);
-                return -EBUSY;
-        }
-        if (_pr->flags.power)
-                err = push_cxx_to_hypervisor(_pr);
-        if (_pr->performance && _pr->performance->states)
-                err |= push_pxx_to_hypervisor(_pr);
-        mutex_unlock(&acpi_ids_mutex);
-        return err;
-}
-static unsigned int __init get_max_acpi_id(void)
-{
-        struct xenpf_pcpuinfo *info;
-        struct xen_platform_op op = {
-                .cmd = XENPF_get_cpuinfo,
-                .interface_version = XENPF_INTERFACE_VERSION,
-        };
-        int ret = 0;
-        unsigned int i, last_cpu, max_acpi_id = 0;
-        info = &op.u.pcpu_info;
-        info->xen_cpuid = 0;
-        ret = HYPERVISOR_dom0_op(&op);
-        if (ret)
-                return NR_CPUS;
-        /* The max_present is the same irregardless of the xen_cpuid */
-        last_cpu = op.u.pcpu_info.max_present;
-        for (i = 0; i <= last_cpu; i++) {
-                info->xen_cpuid = i;
-                ret = HYPERVISOR_dom0_op(&op);
-                if (ret)
-                        continue;
-                max_acpi_id = max(info->acpi_id, max_acpi_id);
-        }
-        max_acpi_id *= 2; /* Slack for CPU hotplug support. */
-        pr_debug(DRV_NAME "Max ACPI ID: %u\n", max_acpi_id);
-        return max_acpi_id;
-}
-/*
- * The read_acpi_id and check_acpi_ids are there to support the Xen
- * oddity of virtual CPUs != physical CPUs in the initial domain.
- * The user can supply 'xen_max_vcpus=X' on the Xen hypervisor line
- * which will band the amount of CPUs the initial domain can see.
- * In general that is OK, except it plays havoc with any of the
- * for_each_[present|online]_cpu macros which are banded to the virtual
- * CPU amount.
- */
-static acpi_status __init
-read_acpi_id(acpi_handle handle, u32 lvl, void *context, void **rv)
-{
-        u32 acpi_id;
-        acpi_status status;
-        acpi_object_type acpi_type;
-        unsigned long long tmp;
-        union acpi_object object = { 0 };
-        struct acpi_buffer buffer = { sizeof(union acpi_object), &object };
-        acpi_io_address pblk = 0;
-        status = acpi_get_type(handle, &acpi_type);
-        if (ACPI_FAILURE(status))
-                return AE_OK;
-        switch (acpi_type) {
-        case ACPI_TYPE_PROCESSOR:
-                status = acpi_evaluate_object(handle, NULL, NULL, &buffer);
-                if (ACPI_FAILURE(status))
-                        return AE_OK;
-                acpi_id = object.processor.proc_id;
-                pblk = object.processor.pblk_address;
-                break;
-        case ACPI_TYPE_DEVICE:
-                status = acpi_evaluate_integer(handle, "_UID", NULL, &tmp);
-                if (ACPI_FAILURE(status))
-                        return AE_OK;
-                acpi_id = tmp;
-                break;
-        default:
-                return AE_OK;
-        }
-        /* There are more ACPI Processor objects than in x2APIC or MADT.
-         * This can happen with incorrect ACPI SSDT declerations. */
-        if (acpi_id > nr_acpi_bits) {
-                pr_debug(DRV_NAME "We only have %u, trying to set %u\n",
-                         nr_acpi_bits, acpi_id);
-                return AE_OK;
-        }
-        /* OK, There is a ACPI Processor object */
-        __set_bit(acpi_id, acpi_id_present);
-        pr_debug(DRV_NAME "ACPI CPU%u w/ PBLK:0x%lx\n", acpi_id,
-                 (unsigned long)pblk);
-        status = acpi_evaluate_object(handle, "_CST", NULL, &buffer);
-        if (ACPI_FAILURE(status)) {
-                if (!pblk)
-                        return AE_OK;
-        }
-        /* .. and it has a C-state */
-        __set_bit(acpi_id, acpi_id_cst_present);
-        return AE_OK;
-}
-static int __init check_acpi_ids(struct acpi_processor *pr_backup)
-{
-        if (!pr_backup)
-                return -ENODEV;
-        /* All online CPUs have been processed at this stage. Now verify
-         * whether in fact "online CPUs" == physical CPUs.
-         */
-        acpi_id_present = kcalloc(BITS_TO_LONGS(nr_acpi_bits), sizeof(unsigned long), GFP_KERNEL);
-        if (!acpi_id_present)
-                return -ENOMEM;
-        acpi_id_cst_present = kcalloc(BITS_TO_LONGS(nr_acpi_bits), sizeof(unsigned long), GFP_KERNEL);
-        if (!acpi_id_cst_present) {
-                kfree(acpi_id_present);
-                return -ENOMEM;
-        }
-        acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
-                            ACPI_UINT32_MAX,
-                            read_acpi_id, NULL, NULL, NULL);
-        acpi_get_devices("ACPI0007", read_acpi_id, NULL, NULL);
-        if (!bitmap_equal(acpi_id_present, acpi_ids_done, nr_acpi_bits)) {
-                unsigned int i;
-                for_each_set_bit(i, acpi_id_present, nr_acpi_bits) {
-                        pr_backup->acpi_id = i;
-                        /* Mask out C-states if there are no _CST or PBLK */
-                        pr_backup->flags.power = test_bit(i, acpi_id_cst_present);
-                        (void)upload_pm_data(pr_backup);
-                }
-        }
-        kfree(acpi_id_present);
-        acpi_id_present = NULL;
-        kfree(acpi_id_cst_present);
-        acpi_id_cst_present = NULL;
-        return 0;
-}
-static int __init check_prereq(void)
-{
-        struct cpuinfo_x86 *c = &cpu_data(0);
-        if (!xen_initial_domain())
-                return -ENODEV;
-        if (!acpi_gbl_FADT.smi_command)
-                return -ENODEV;
-        if (c->x86_vendor == X86_VENDOR_INTEL) {
-                if (!cpu_has(c, X86_FEATURE_EST))
-                        return -ENODEV;
-                return 0;
-        }
-        if (c->x86_vendor == X86_VENDOR_AMD) {
-                /* Copied from powernow-k8.h, can't include ../cpufreq/powernow
-                 * as we get compile warnings for the static functions.
-                 */
-#define CPUID_FREQ_VOLT_CAPABILITIES    0x80000007
-#define USE_HW_PSTATE                   0x00000080
-                u32 eax, ebx, ecx, edx;
-                cpuid(CPUID_FREQ_VOLT_CAPABILITIES, &eax, &ebx, &ecx, &edx);
-                if ((edx & USE_HW_PSTATE) != USE_HW_PSTATE)
-                        return -ENODEV;
-                return 0;
-        }
-        return -ENODEV;
-}
-/* acpi_perf_data is a pointer to percpu data. */
-static struct acpi_processor_performance __percpu *acpi_perf_data;
-static void free_acpi_perf_data(void)
-{
-        unsigned int i;
-        /* Freeing a NULL pointer is OK, and alloc_percpu zeroes. */
-        for_each_possible_cpu(i)
-                free_cpumask_var(per_cpu_ptr(acpi_perf_data, i)
-                                 ->shared_cpu_map);
-        free_percpu(acpi_perf_data);
-}
-static int __init xen_acpi_processor_init(void)
-{
-        struct acpi_processor *pr_backup = NULL;
-        unsigned int i;
-        int rc = check_prereq();
-        if (rc)
-                return rc;
-        nr_acpi_bits = get_max_acpi_id() + 1;
-        acpi_ids_done = kcalloc(BITS_TO_LONGS(nr_acpi_bits), sizeof(unsigned long), GFP_KERNEL);
-        if (!acpi_ids_done)
-                return -ENOMEM;
-        acpi_perf_data = alloc_percpu(struct acpi_processor_performance);
-        if (!acpi_perf_data) {
-                pr_debug(DRV_NAME "Memory allocation error for acpi_perf_data.\n");
-                kfree(acpi_ids_done);
-                return -ENOMEM;
-        }
-        for_each_possible_cpu(i) {
-                if (!zalloc_cpumask_var_node(
-                        &per_cpu_ptr(acpi_perf_data, i)->shared_cpu_map,
-                        GFP_KERNEL, cpu_to_node(i))) {
-                        rc = -ENOMEM;
-                        goto err_out;
-                }
-        }
-        /* Do initialization in ACPI core. It is OK to fail here. */
-        (void)acpi_processor_preregister_performance(acpi_perf_data);
-        for_each_possible_cpu(i) {
-                struct acpi_processor_performance *perf;
-                perf = per_cpu_ptr(acpi_perf_data, i);
-                rc = acpi_processor_register_performance(perf, i);
-                if (rc)
-                        goto err_out;
-        }
-        rc = acpi_processor_notify_smm(THIS_MODULE);
-        if (rc)
-                goto err_unregister;
-        for_each_possible_cpu(i) {
-                struct acpi_processor *_pr;
-                _pr = per_cpu(processors, i /* APIC ID */);
-                if (!_pr)
-                        continue;
-                if (!pr_backup) {
-                        pr_backup = kzalloc(sizeof(struct acpi_processor), GFP_KERNEL);
-                        if (pr_backup)
-                                memcpy(pr_backup, _pr, sizeof(struct acpi_processor));
-                }
-                (void)upload_pm_data(_pr);
-        }
-        rc = check_acpi_ids(pr_backup);
-        kfree(pr_backup);
-        pr_backup = NULL;
-        if (rc)
-                goto err_unregister;
-        return 0;
-err_unregister:
-        for_each_possible_cpu(i) {
-                struct acpi_processor_performance *perf;
-                perf = per_cpu_ptr(acpi_perf_data, i);
-                acpi_processor_unregister_performance(perf, i);
-        }
-err_out:
-        /* Freeing a NULL pointer is OK: alloc_percpu zeroes. */
-        free_acpi_perf_data();
-        kfree(acpi_ids_done);
-        return rc;
-}
-static void __exit xen_acpi_processor_exit(void)
-{
-        int i;
-        kfree(acpi_ids_done);
-        for_each_possible_cpu(i) {
-                struct acpi_processor_performance *perf;
-                perf = per_cpu_ptr(acpi_perf_data, i);
-                acpi_processor_unregister_performance(perf, i);
-        }
-        free_acpi_perf_data();
-}
-MODULE_AUTHOR("Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>");
-MODULE_DESCRIPTION("Xen ACPI Processor P-states (and Cx) driver which uploads PM data to Xen hypervisor");
-MODULE_LICENSE("GPL");
-/* We want to be loaded before the CPU freq scaling drivers are loaded.
- * They are loaded in late_initcall. */
-device_initcall(xen_acpi_processor_init);
-module_exit(xen_acpi_processor_exit);
diff --git a/drivers/xen/xen-balloon.c b/drivers/xen/xen-balloon.c
index 8f37e23f6d1..5c9dc43c1e9 100644
--- a/drivers/xen/xen-balloon.c
+++ b/drivers/xen/xen-balloon.c
@@ -32,6 +32,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
+#include <linux/sysdev.h>
 #include <linux/capability.h>
 #include <xen/xen.h>
@@ -45,9 +46,14 @@
 #define BALLOON_CLASS_NAME "xen_memory"
-static struct device balloon_dev;
+static struct sys_device balloon_sysdev;
-static int register_balloon(struct device *dev);
+static int register_balloon(struct sys_device *sysdev);
+static struct xenbus_watch target_watch =
+{
+        .node = "memory/target"
+};
 /* React to a change in the target key */
 static void watch_target(struct xenbus_watch *watch,
@@ -67,11 +73,6 @@ static void watch_target(struct xenbus_watch *watch,
         */
        balloon_set_new_target(new_target >> (PAGE_SHIFT - 10));
 }
-static struct xenbus_watch target_watch = {
-        .node = "memory/target",
-        .callback = watch_target,
-};
 static int balloon_init_watcher(struct notifier_block *notifier,
                                unsigned long event,
@@ -86,9 +87,7 @@ static int balloon_init_watcher(struct notifier_block *notifier,
        return NOTIFY_DONE;
 }
-static struct notifier_block xenstore_notifier = {
+static struct notifier_block xenstore_notifier;
-        .notifier_call = balloon_init_watcher,
-};
 static int __init balloon_init(void)
 {
@@ -97,9 +96,12 @@ static int __init balloon_init(void)
        pr_info("xen-balloon: Initialising balloon driver.\n");
-        register_balloon(&balloon_dev);
+        register_balloon(&balloon_sysdev);
+        register_xen_selfballooning(&balloon_sysdev);
-        register_xen_selfballooning(&balloon_dev);
+        target_watch.callback = watch_target;
+        xenstore_notifier.notifier_call = balloon_init_watcher;
        register_xenstore_notifier(&xenstore_notifier);
@@ -116,31 +118,31 @@ static void balloon_exit(void)
 module_exit(balloon_exit);
 #define BALLOON_SHOW(name, format, args...)                             \
-        static ssize_t show_##name(struct device *dev,                  \
+        static ssize_t show_##name(struct sys_device *dev,              \
-                                   struct device_attribute *attr,       \
+                                   struct sysdev_attribute *attr,       \
                                   char *buf)                           \
        {                                                               \
                return sprintf(buf, format, ##args);                    \
        }                                                               \
-        static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
+        static SYSDEV_ATTR(name, S_IRUGO, show_##name, NULL)
 BALLOON_SHOW(current_kb, "%lu\n", PAGES2KB(balloon_stats.current_pages));
 BALLOON_SHOW(low_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_low));
 BALLOON_SHOW(high_kb, "%lu\n", PAGES2KB(balloon_stats.balloon_high));
-static DEVICE_ULONG_ATTR(schedule_delay, 0444, balloon_stats.schedule_delay);
+static SYSDEV_ULONG_ATTR(schedule_delay, 0444, balloon_stats.schedule_delay);
-static DEVICE_ULONG_ATTR(max_schedule_delay, 0644, balloon_stats.max_schedule_delay);
+static SYSDEV_ULONG_ATTR(max_schedule_delay, 0644, balloon_stats.max_schedule_delay);
-static DEVICE_ULONG_ATTR(retry_count, 0444, balloon_stats.retry_count);
+static SYSDEV_ULONG_ATTR(retry_count, 0444, balloon_stats.retry_count);
-static DEVICE_ULONG_ATTR(max_retry_count, 0644, balloon_stats.max_retry_count);
+static SYSDEV_ULONG_ATTR(max_retry_count, 0644, balloon_stats.max_retry_count);
-static ssize_t show_target_kb(struct device *dev, struct device_attribute *attr,
+static ssize_t show_target_kb(struct sys_device *dev, struct sysdev_attribute *attr,
                              char *buf)
 {
        return sprintf(buf, "%lu\n", PAGES2KB(balloon_stats.target_pages));
 }
-static ssize_t store_target_kb(struct device *dev,
+static ssize_t store_target_kb(struct sys_device *dev,
-                               struct device_attribute *attr,
+                               struct sysdev_attribute *attr,
                               const char *buf,
                               size_t count)
 {
@@ -157,11 +159,11 @@ static ssize_t store_target_kb(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(target_kb, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(target_kb, S_IRUGO | S_IWUSR,
                   show_target_kb, store_target_kb);
-static ssize_t show_target(struct device *dev, struct device_attribute *attr,
+static ssize_t show_target(struct sys_device *dev, struct sysdev_attribute *attr,
                              char *buf)
 {
        return sprintf(buf, "%llu\n",
@@ -169,8 +171,8 @@ static ssize_t show_target(struct device *dev, struct device_attribute *attr,
                       << PAGE_SHIFT);
 }
-static ssize_t store_target(struct device *dev,
+static ssize_t store_target(struct sys_device *dev,
-                            struct device_attribute *attr,
+                            struct sysdev_attribute *attr,
                            const char *buf,
                            size_t count)
 {
@@ -187,60 +189,59 @@ static ssize_t store_target(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(target, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(target, S_IRUGO | S_IWUSR,
                   show_target, store_target);
-static struct device_attribute *balloon_attrs[] = {
+static struct sysdev_attribute *balloon_attrs[] = {
-        &dev_attr_target_kb,
+        &attr_target_kb,
-        &dev_attr_target,
+        &attr_target,
-        &dev_attr_schedule_delay.attr,
+        &attr_schedule_delay.attr,
-        &dev_attr_max_schedule_delay.attr,
+        &attr_max_schedule_delay.attr,
-        &dev_attr_retry_count.attr,
+        &attr_retry_count.attr,
-        &dev_attr_max_retry_count.attr
+        &attr_max_retry_count.attr
 };
 static struct attribute *balloon_info_attrs[] = {
-        &dev_attr_current_kb.attr,
+        &attr_current_kb.attr,
-        &dev_attr_low_kb.attr,
+        &attr_low_kb.attr,
-        &dev_attr_high_kb.attr,
+        &attr_high_kb.attr,
        NULL
 };
-static const struct attribute_group balloon_info_group = {
+static struct attribute_group balloon_info_group = {
        .name = "info",
        .attrs = balloon_info_attrs
 };
-static struct bus_type balloon_subsys = {
+static struct sysdev_class balloon_sysdev_class = {
-        .name = BALLOON_CLASS_NAME,
+        .name = BALLOON_CLASS_NAME
-        .dev_name = BALLOON_CLASS_NAME,
 };
-static int register_balloon(struct device *dev)
+static int register_balloon(struct sys_device *sysdev)
 {
        int i, error;
-        error = subsys_system_register(&balloon_subsys, NULL);
+        error = sysdev_class_register(&balloon_sysdev_class);
        if (error)
                return error;
-        dev->id = 0;
+        sysdev->id = 0;
-        dev->bus = &balloon_subsys;
+        sysdev->cls = &balloon_sysdev_class;
-        error = device_register(dev);
+        error = sysdev_register(sysdev);
        if (error) {
-                bus_unregister(&balloon_subsys);
+                sysdev_class_unregister(&balloon_sysdev_class);
                return error;
        }
        for (i = 0; i < ARRAY_SIZE(balloon_attrs); i++) {
-                error = device_create_file(dev, balloon_attrs[i]);
+                error = sysdev_create_file(sysdev, balloon_attrs[i]);
                if (error)
                        goto fail;
        }
-        error = sysfs_create_group(&dev->kobj, &balloon_info_group);
+        error = sysfs_create_group(&sysdev->kobj, &balloon_info_group);
        if (error)
                goto fail;
@@ -248,9 +249,9 @@ static int register_balloon(struct device *dev)
 fail:
        while (--i >= 0)
-                device_remove_file(dev, balloon_attrs[i]);
+                sysdev_remove_file(sysdev, balloon_attrs[i]);
-        device_unregister(dev);
+        sysdev_unregister(sysdev);
-        bus_unregister(&balloon_subsys);
+        sysdev_class_unregister(&balloon_sysdev_class);
        return error;
 }
diff --git a/drivers/xen/xen-pciback/conf_space.c b/drivers/xen/xen-pciback/conf_space.c
index 46ae0f9f02a..a8031445d94 100644
--- a/drivers/xen/xen-pciback/conf_space.c
+++ b/drivers/xen/xen-pciback/conf_space.c
@@ -10,13 +10,13 @@
 */
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/pci.h>
 #include "pciback.h"
 #include "conf_space.h"
 #include "conf_space_quirks.h"
-static bool permissive;
+#define DRV_NAME        "xen-pciback"
+static int permissive;
 module_param(permissive, bool, 0644);
 /* This is where xen_pcibk_read_config_byte, xen_pcibk_read_config_word,
@@ -124,7 +124,7 @@ static inline u32 merge_value(u32 val, u32 new_val, u32 new_val_mask,
        return val;
 }
-static int xen_pcibios_err_to_errno(int err)
+static int pcibios_err_to_errno(int err)
 {
        switch (err) {
        case PCIBIOS_SUCCESSFUL:
@@ -202,7 +202,7 @@ out:
                       pci_name(dev), size, offset, value);
        *ret_val = value;
-        return xen_pcibios_err_to_errno(err);
+        return pcibios_err_to_errno(err);
 }
 int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value)
@@ -290,7 +290,7 @@ int xen_pcibk_config_write(struct pci_dev *dev, int offset, int size, u32 value)
                }
        }
-        return xen_pcibios_err_to_errno(err);
+        return pcibios_err_to_errno(err);
 }
 void xen_pcibk_config_free_dyn_fields(struct pci_dev *dev)
diff --git a/drivers/xen/xen-pciback/conf_space_header.c b/drivers/xen/xen-pciback/conf_space_header.c
index 3daf862d739..da3cbdfcb5d 100644
--- a/drivers/xen/xen-pciback/conf_space_header.c
+++ b/drivers/xen/xen-pciback/conf_space_header.c
@@ -15,6 +15,7 @@ struct pci_bar_info {
        int which;
 };
+#define DRV_NAME        "xen-pciback"
 #define is_enable_cmd(value) ((value)&(PCI_COMMAND_MEMORY|PCI_COMMAND_IO))
 #define is_master_cmd(value) ((value)&PCI_COMMAND_MASTER)
@@ -24,7 +25,7 @@ static int command_read(struct pci_dev *dev, int offset, u16 *value, void *data)
        int ret;
        ret = xen_pcibk_read_config_word(dev, offset, value, data);
-        if (!pci_is_enabled(dev))
+        if (!atomic_read(&dev->enable_cnt))
                return ret;
        for (i = 0; i < PCI_ROM_RESOURCE; i++) {
@@ -186,7 +187,7 @@ static inline void read_dev_bar(struct pci_dev *dev,
        bar_info->val = res[pos].start |
                        (res[pos].flags & PCI_REGION_FLAG_MASK);
-        bar_info->len_val = resource_size(&res[pos]);
+        bar_info->len_val = res[pos].end - res[pos].start + 1;
 }
 static void *bar_init(struct pci_dev *dev, int offset)
diff --git a/drivers/xen/xen-pciback/conf_space_quirks.c b/drivers/xen/xen-pciback/conf_space_quirks.c
index 7476791cab4..921a889e65e 100644
--- a/drivers/xen/xen-pciback/conf_space_quirks.c
+++ b/drivers/xen/xen-pciback/conf_space_quirks.c
@@ -12,6 +12,7 @@
 #include "conf_space_quirks.h"
 LIST_HEAD(xen_pcibk_quirks);
+#define DRV_NAME        "xen-pciback"
 static inline const struct pci_device_id *
 match_one_device(const struct pci_device_id *id, const struct pci_dev *dev)
 {
@@ -35,7 +36,7 @@ static struct xen_pcibk_config_quirk *xen_pcibk_find_quirk(struct pci_dev *dev)
                        goto out;
        tmp_quirk = NULL;
        printk(KERN_DEBUG DRV_NAME
-               ": quirk didn't match any device known\n");
+               ":quirk didn't match any device xen_pciback knows about\n");
 out:
        return tmp_quirk;
 }
diff --git a/drivers/xen/xen-pciback/passthrough.c b/drivers/xen/xen-pciback/passthrough.c
index 828dddc360d..1d32a9a42c0 100644
--- a/drivers/xen/xen-pciback/passthrough.c
+++ b/drivers/xen/xen-pciback/passthrough.c
@@ -7,13 +7,13 @@
 #include <linux/list.h>
 #include <linux/pci.h>
-#include <linux/mutex.h>
+#include <linux/spinlock.h>
 #include "pciback.h"
 struct passthrough_dev_data {
        /* Access to dev_list must be protected by lock */
        struct list_head dev_list;
-        struct mutex lock;
+        spinlock_t lock;
 };
 static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
@@ -24,8 +24,9 @@ static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
        struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
        struct pci_dev_entry *dev_entry;
        struct pci_dev *dev = NULL;
+        unsigned long flags;
-        mutex_lock(&dev_data->lock);
+        spin_lock_irqsave(&dev_data->lock, flags);
        list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
                if (domain == (unsigned int)pci_domain_nr(dev_entry->dev->bus)
@@ -36,7 +37,7 @@ static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
                }
        }
-        mutex_unlock(&dev_data->lock);
+        spin_unlock_irqrestore(&dev_data->lock, flags);
        return dev;
 }
@@ -47,6 +48,7 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
 {
        struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
        struct pci_dev_entry *dev_entry;
+        unsigned long flags;
        unsigned int domain, bus, devfn;
        int err;
@@ -55,9 +57,9 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
                return -ENOMEM;
        dev_entry->dev = dev;
-        mutex_lock(&dev_data->lock);
+        spin_lock_irqsave(&dev_data->lock, flags);
        list_add_tail(&dev_entry->list, &dev_data->dev_list);
-        mutex_unlock(&dev_data->lock);
+        spin_unlock_irqrestore(&dev_data->lock, flags);
        /* Publish this device. */
        domain = (unsigned int)pci_domain_nr(dev->bus);
@@ -74,8 +76,9 @@ static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
        struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
        struct pci_dev_entry *dev_entry, *t;
        struct pci_dev *found_dev = NULL;
+        unsigned long flags;
-        mutex_lock(&dev_data->lock);
+        spin_lock_irqsave(&dev_data->lock, flags);
        list_for_each_entry_safe(dev_entry, t, &dev_data->dev_list, list) {
                if (dev_entry->dev == dev) {
@@ -85,7 +88,7 @@ static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
                }
        }
-        mutex_unlock(&dev_data->lock);
+        spin_unlock_irqrestore(&dev_data->lock, flags);
        if (found_dev)
                pcistub_put_pci_dev(found_dev);
@@ -99,7 +102,7 @@ static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
        if (!dev_data)
                return -ENOMEM;
-        mutex_init(&dev_data->lock);
+        spin_lock_init(&dev_data->lock);
        INIT_LIST_HEAD(&dev_data->dev_list);
@@ -113,14 +116,14 @@ static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
 {
        int err = 0;
        struct passthrough_dev_data *dev_data = pdev->pci_dev_data;
-        struct pci_dev_entry *dev_entry, *e;
+        struct pci_dev_entry *dev_entry, *e, *tmp;
        struct pci_dev *dev;
        int found;
        unsigned int domain, bus;
-        mutex_lock(&dev_data->lock);
+        spin_lock(&dev_data->lock);
-        list_for_each_entry(dev_entry, &dev_data->dev_list, list) {
+        list_for_each_entry_safe(dev_entry, tmp, &dev_data->dev_list, list) {
                /* Only publish this device as a root if none of its
                 * parent bridges are exported
                 */
@@ -139,13 +142,16 @@ static int __xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
                bus = (unsigned int)dev_entry->dev->bus->number;
                if (!found) {
+                        spin_unlock(&dev_data->lock);
                        err = publish_root_cb(pdev, domain, bus);
                        if (err)
                                break;
+                        spin_lock(&dev_data->lock);
                }
        }
-        mutex_unlock(&dev_data->lock);
+        if (!err)
+                spin_unlock(&dev_data->lock);
        return err;
 }
@@ -176,7 +182,7 @@ static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
        return 1;
 }
-const struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
+struct xen_pcibk_backend xen_pcibk_passthrough_backend = {
        .name           = "passthrough",
        .init           = __xen_pcibk_init_devices,
        .free           = __xen_pcibk_release_devices,
diff --git a/drivers/xen/xen-pciback/pci_stub.c b/drivers/xen/xen-pciback/pci_stub.c
index 9204126f156..aec214ac0a1 100644
--- a/drivers/xen/xen-pciback/pci_stub.c
+++ b/drivers/xen/xen-pciback/pci_stub.c
@@ -21,6 +21,8 @@
 #include "conf_space.h"
 #include "conf_space_quirks.h"
+#define DRV_NAME        "xen-pciback"
 static char *pci_devs_to_hide;
 wait_queue_head_t xen_pcibk_aer_wait_queue;
 /*Add sem for sync AER handling and xen_pcibk remove/reconfigue ops,
@@ -85,36 +87,20 @@ static struct pcistub_device *pcistub_device_alloc(struct pci_dev *dev)
 static void pcistub_device_release(struct kref *kref)
 {
        struct pcistub_device *psdev;
-        struct xen_pcibk_dev_data *dev_data;
        psdev = container_of(kref, struct pcistub_device, kref);
-        dev_data = pci_get_drvdata(psdev->dev);
        dev_dbg(&psdev->dev->dev, "pcistub_device_release\n");
        xen_unregister_device_domain_owner(psdev->dev);
-        /* Call the reset function which does not take lock as this
-         * is called from "unbind" which takes a device_lock mutex.
-         */
-        __pci_reset_function_locked(psdev->dev);
-        if (pci_load_and_free_saved_state(psdev->dev,
-                                          &dev_data->pci_saved_state)) {
-                dev_dbg(&psdev->dev->dev, "Could not reload PCI state\n");
-        } else
-                pci_restore_state(psdev->dev);
-        /* Disable the device */
-        xen_pcibk_reset_device(psdev->dev);
-        kfree(dev_data);
-        pci_set_drvdata(psdev->dev, NULL);
        /* Clean-up the device */
+        xen_pcibk_reset_device(psdev->dev);
        xen_pcibk_config_free_dyn_fields(psdev->dev);
        xen_pcibk_config_free_dev(psdev->dev);
+        kfree(pci_get_drvdata(psdev->dev));
+        pci_set_drvdata(psdev->dev, NULL);
-        psdev->dev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED;
        pci_dev_put(psdev->dev);
        kfree(psdev);
@@ -142,8 +128,7 @@ static struct pcistub_device *pcistub_device_find(int domain, int bus,
                if (psdev->dev != NULL
                    && domain == pci_domain_nr(psdev->dev->bus)
                    && bus == psdev->dev->bus->number
-                    && slot == PCI_SLOT(psdev->dev->devfn)
+                    && PCI_DEVFN(slot, func) == psdev->dev->devfn) {
-                    && func == PCI_FUNC(psdev->dev->devfn)) {
                        pcistub_device_get(psdev);
                        goto out;
                }
@@ -192,8 +177,7 @@ struct pci_dev *pcistub_get_pci_dev_by_slot(struct xen_pcibk_device *pdev,
                if (psdev->dev != NULL
                    && domain == pci_domain_nr(psdev->dev->bus)
                    && bus == psdev->dev->bus->number
-                    && slot == PCI_SLOT(psdev->dev->devfn)
+                    && PCI_DEVFN(slot, func) == psdev->dev->devfn) {
-                    && func == PCI_FUNC(psdev->dev->devfn)) {
                        found_dev = pcistub_device_get_pci_dev(pdev, psdev);
                        break;
                }
@@ -238,8 +222,6 @@ void pcistub_put_pci_dev(struct pci_dev *dev)
        }
        spin_unlock_irqrestore(&pcistub_devices_lock, flags);
-        if (WARN_ON(!found_psdev))
-                return;
        /*hold this lock for avoiding breaking link between
        * pcistub and xen_pcibk when AER is in processing
@@ -248,22 +230,10 @@ void pcistub_put_pci_dev(struct pci_dev *dev)
        /* Cleanup our device
         * (so it's ready for the next domain)
         */
-        /* This is OK - we are running from workqueue context
-         * and want to inhibit the user from fiddling with 'reset'
-         */
-        pci_reset_function(dev);
-        pci_restore_state(psdev->dev);
-        /* This disables the device. */
        xen_pcibk_reset_device(found_psdev->dev);
-        /* And cleanup up our emulated fields. */
        xen_pcibk_config_free_dyn_fields(found_psdev->dev);
        xen_pcibk_config_reset_dev(found_psdev->dev);
-        xen_unregister_device_domain_owner(found_psdev->dev);
        spin_lock_irqsave(&found_psdev->lock, flags);
        found_psdev->pdev = NULL;
        spin_unlock_irqrestore(&found_psdev->lock, flags);
@@ -272,8 +242,8 @@ void pcistub_put_pci_dev(struct pci_dev *dev)
        up_write(&pcistub_sem);
 }
-static int pcistub_match_one(struct pci_dev *dev,
+static int __devinit pcistub_match_one(struct pci_dev *dev,
-                             struct pcistub_device_id *pdev_id)
+                                       struct pcistub_device_id *pdev_id)
 {
        /* Match the specified device by domain, bus, slot, func and also if
         * any of the device's parent bridges match.
@@ -292,7 +262,7 @@ static int pcistub_match_one(struct pci_dev *dev,
        return 0;
 }
-static int pcistub_match(struct pci_dev *dev)
+static int __devinit pcistub_match(struct pci_dev *dev)
 {
        struct pcistub_device_id *pdev_id;
        unsigned long flags;
@@ -310,7 +280,7 @@ static int pcistub_match(struct pci_dev *dev)
        return found;
 }
-static int pcistub_init_device(struct pci_dev *dev)
+static int __devinit pcistub_init_device(struct pci_dev *dev)
 {
        struct xen_pcibk_dev_data *dev_data;
        int err = 0;
@@ -355,24 +325,12 @@ static int pcistub_init_device(struct pci_dev *dev)
        if (err)
                goto config_release;
-        /* We need the device active to save the state. */
-        dev_dbg(&dev->dev, "save state of device\n");
-        pci_save_state(dev);
-        dev_data->pci_saved_state = pci_store_saved_state(dev);
-        if (!dev_data->pci_saved_state)
-                dev_err(&dev->dev, "Could not store PCI conf saved state!\n");
-        else {
-                dev_dbg(&dev->dev, "resetting (FLR, D3, etc) the device\n");
-                __pci_reset_function_locked(dev);
-                pci_restore_state(dev);
-        }
        /* Now disable the device (this also ensures some private device
         * data is setup before we export)
         */
        dev_dbg(&dev->dev, "reset device\n");
        xen_pcibk_reset_device(dev);
-        dev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
        return 0;
 config_release:
@@ -428,7 +386,7 @@ static int __init pcistub_init_devices_late(void)
        return 0;
 }
-static int pcistub_seize(struct pci_dev *dev)
+static int __devinit pcistub_seize(struct pci_dev *dev)
 {
        struct pcistub_device *psdev;
        unsigned long flags;
@@ -463,7 +421,8 @@ static int pcistub_seize(struct pci_dev *dev)
        return err;
 }
-static int pcistub_probe(struct pci_dev *dev, const struct pci_device_id *id)
+static int __devinit pcistub_probe(struct pci_dev *dev,
+                                   const struct pci_device_id *id)
 {
        int err = 0;
@@ -555,9 +514,12 @@ static void kill_domain_by_device(struct pcistub_device *psdev)
        int err;
        char nodename[PCI_NODENAME_MAX];
-        BUG_ON(!psdev);
+        if (!psdev)
+                dev_err(&psdev->dev->dev,
+                        "device is NULL when do AER recovery/kill_domain\n");
        snprintf(nodename, PCI_NODENAME_MAX, "/local/domain/0/backend/pci/%d/0",
                psdev->pdev->xdev->otherend_id);
+        nodename[strlen(nodename)] = '\0';
 again:
        err = xenbus_transaction_start(&xbt);
@@ -643,7 +605,7 @@ static pci_ers_result_t common_process(struct pcistub_device *psdev,
        if (test_bit(_XEN_PCIF_active,
                (unsigned long *)&psdev->pdev->sh_info->flags)) {
                dev_dbg(&psdev->dev->dev,
-                        "schedule pci_conf service in " DRV_NAME "\n");
+                        "schedule pci_conf service in xen_pcibk\n");
                xen_pcibk_test_and_schedule_op(psdev->pdev);
        }
@@ -683,14 +645,14 @@ static pci_ers_result_t xen_pcibk_slot_reset(struct pci_dev *dev)
                dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                        " by HVM, kill it\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        if (!test_bit(_XEN_PCIB_AERHANDLER,
                (unsigned long *)&psdev->pdev->sh_info->flags)) {
                dev_err(&dev->dev,
                        "guest with no AER driver should have been killed\n");
-                goto end;
+                goto release;
        }
        result = common_process(psdev, 1, XEN_PCI_OP_aer_slotreset, result);
@@ -700,9 +662,9 @@ static pci_ers_result_t xen_pcibk_slot_reset(struct pci_dev *dev)
                        "No AER slot_reset service or disconnected!\n");
                kill_domain_by_device(psdev);
        }
+release:
+        pcistub_device_put(psdev);
 end:
-        if (psdev)
-                pcistub_device_put(psdev);
        up_write(&pcistub_sem);
        return result;
@@ -741,14 +703,14 @@ static pci_ers_result_t xen_pcibk_mmio_enabled(struct pci_dev *dev)
                dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                        " by HVM, kill it\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        if (!test_bit(_XEN_PCIB_AERHANDLER,
                (unsigned long *)&psdev->pdev->sh_info->flags)) {
                dev_err(&dev->dev,
                        "guest with no AER driver should have been killed\n");
-                goto end;
+                goto release;
        }
        result = common_process(psdev, 1, XEN_PCI_OP_aer_mmio, result);
@@ -758,9 +720,9 @@ static pci_ers_result_t xen_pcibk_mmio_enabled(struct pci_dev *dev)
                        "No AER mmio_enabled service or disconnected!\n");
                kill_domain_by_device(psdev);
        }
+release:
+        pcistub_device_put(psdev);
 end:
-        if (psdev)
-                pcistub_device_put(psdev);
        up_write(&pcistub_sem);
        return result;
 }
@@ -799,7 +761,7 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                        " by HVM, kill it\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        /*Guest owns the device yet no aer handler regiested, kill guest*/
@@ -807,7 +769,7 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                (unsigned long *)&psdev->pdev->sh_info->flags)) {
                dev_dbg(&dev->dev, "guest may have no aer driver, kill it\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        result = common_process(psdev, error, XEN_PCI_OP_aer_detected, result);
@@ -817,9 +779,9 @@ static pci_ers_result_t xen_pcibk_error_detected(struct pci_dev *dev,
                        "No AER error_detected service or disconnected!\n");
                kill_domain_by_device(psdev);
        }
+release:
+        pcistub_device_put(psdev);
 end:
-        if (psdev)
-                pcistub_device_put(psdev);
        up_write(&pcistub_sem);
        return result;
 }
@@ -853,7 +815,7 @@ static void xen_pcibk_error_resume(struct pci_dev *dev)
                dev_err(&dev->dev, DRV_NAME " device is not connected or owned"
                        " by HVM, kill it\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        if (!test_bit(_XEN_PCIB_AERHANDLER,
@@ -861,19 +823,19 @@ static void xen_pcibk_error_resume(struct pci_dev *dev)
                dev_err(&dev->dev,
                        "guest with no AER driver should have been killed\n");
                kill_domain_by_device(psdev);
-                goto end;
+                goto release;
        }
        common_process(psdev, 1, XEN_PCI_OP_aer_resume,
                       PCI_ERS_RESULT_RECOVERED);
+release:
+        pcistub_device_put(psdev);
 end:
-        if (psdev)
-                pcistub_device_put(psdev);
        up_write(&pcistub_sem);
        return;
 }
 /*add xen_pcibk AER handling*/
-static const struct pci_error_handlers xen_pcibk_error_handler = {
+static struct pci_error_handlers xen_pcibk_error_handler = {
        .error_detected = xen_pcibk_error_detected,
        .mmio_enabled = xen_pcibk_mmio_enabled,
        .slot_reset = xen_pcibk_slot_reset,
@@ -898,35 +860,18 @@ static struct pci_driver xen_pcibk_pci_driver = {
 static inline int str_to_slot(const char *buf, int *domain, int *bus,
                              int *slot, int *func)
 {
-        int parsed = 0;
+        int err;
-        switch (sscanf(buf, " %x:%x:%x.%x %n", domain, bus, slot, func,
+        err = sscanf(buf, " %x:%x:%x.%x", domain, bus, slot, func);
-                       &parsed)) {
+        if (err == 4)
-        case 3:
-                *func = -1;
-                sscanf(buf, " %x:%x:%x.* %n", domain, bus, slot, &parsed);
-                break;
-        case 2:
-                *slot = *func = -1;
-                sscanf(buf, " %x:%x:*.* %n", domain, bus, &parsed);
-                break;
-        }
-        if (parsed && !buf[parsed])
                return 0;
+        else if (err < 0)
+                return -EINVAL;
        /* try again without domain */
        *domain = 0;
-        switch (sscanf(buf, " %x:%x.%x %n", bus, slot, func, &parsed)) {
+        err = sscanf(buf, " %x:%x.%x", bus, slot, func);
-        case 2:
+        if (err == 3)
-                *func = -1;
-                sscanf(buf, " %x:%x.* %n", bus, slot, &parsed);
-                break;
-        case 1:
-                *slot = *func = -1;
-                sscanf(buf, " %x:*.* %n", bus, &parsed);
-                break;
-        }
-        if (parsed && !buf[parsed])
                return 0;
        return -EINVAL;
@@ -935,20 +880,13 @@ static inline int str_to_slot(const char *buf, int *domain, int *bus,
 static inline int str_to_quirk(const char *buf, int *domain, int *bus, int
                               *slot, int *func, int *reg, int *size, int *mask)
 {
-        int parsed = 0;
+        int err;
-        sscanf(buf, " %x:%x:%x.%x-%x:%x:%x %n", domain, bus, slot, func,
+        err =
-               reg, size, mask, &parsed);
+            sscanf(buf, " %04x:%02x:%02x.%1x-%08x:%1x:%08x", domain, bus, slot,
-        if (parsed && !buf[parsed])
+                   func, reg, size, mask);
+        if (err == 7)
                return 0;
-        /* try again without domain */
-        *domain = 0;
-        sscanf(buf, " %x:%x.%x-%x:%x:%x %n", bus, slot, func, reg, size,
-               mask, &parsed);
-        if (parsed && !buf[parsed])
-                return 0;
        return -EINVAL;
 }
@@ -956,30 +894,6 @@ static int pcistub_device_id_add(int domain, int bus, int slot, int func)
 {
        struct pcistub_device_id *pci_dev_id;
        unsigned long flags;
-        int rc = 0, devfn = PCI_DEVFN(slot, func);
-        if (slot < 0) {
-                for (slot = 0; !rc && slot < 32; ++slot)
-                        rc = pcistub_device_id_add(domain, bus, slot, func);
-                return rc;
-        }
-        if (func < 0) {
-                for (func = 0; !rc && func < 8; ++func)
-                        rc = pcistub_device_id_add(domain, bus, slot, func);
-                return rc;
-        }
-        if ((
-#if !defined(MODULE) /* pci_domains_supported is not being exported */ \
-    || !defined(CONFIG_PCI_DOMAINS)
-             !pci_domains_supported ? domain :
-#endif
-             domain < 0 || domain > 0xffff)
-            || bus < 0 || bus > 0xff
-            || PCI_SLOT(devfn) != slot
-            || PCI_FUNC(devfn) != func)
-                return -EINVAL;
        pci_dev_id = kmalloc(sizeof(*pci_dev_id), GFP_KERNEL);
        if (!pci_dev_id)
@@ -987,9 +901,9 @@ static int pcistub_device_id_add(int domain, int bus, int slot, int func)
        pci_dev_id->domain = domain;
        pci_dev_id->bus = bus;
-        pci_dev_id->devfn = devfn;
+        pci_dev_id->devfn = PCI_DEVFN(slot, func);
-        pr_debug(DRV_NAME ": wants to seize %04x:%02x:%02x.%d\n",
+        pr_debug(DRV_NAME ": wants to seize %04x:%02x:%02x.%01x\n",
                 domain, bus, slot, func);
        spin_lock_irqsave(&device_ids_lock, flags);
@@ -1002,15 +916,15 @@ static int pcistub_device_id_add(int domain, int bus, int slot, int func)
 static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
 {
        struct pcistub_device_id *pci_dev_id, *t;
+        int devfn = PCI_DEVFN(slot, func);
        int err = -ENOENT;
        unsigned long flags;
        spin_lock_irqsave(&device_ids_lock, flags);
        list_for_each_entry_safe(pci_dev_id, t, &pcistub_device_ids,
                                 slot_list) {
-                if (pci_dev_id->domain == domain && pci_dev_id->bus == bus
+                if (pci_dev_id->domain == domain
-                    && (slot < 0 || PCI_SLOT(pci_dev_id->devfn) == slot)
+                    && pci_dev_id->bus == bus && pci_dev_id->devfn == devfn) {
-                    && (func < 0 || PCI_FUNC(pci_dev_id->devfn) == func)) {
                        /* Don't break; here because it's possible the same
                         * slot could be in the list more than once
                         */
@@ -1019,7 +933,7 @@ static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
                        err = 0;
-                        pr_debug(DRV_NAME ": removed %04x:%02x:%02x.%d from "
+                        pr_debug(DRV_NAME ": removed %04x:%02x:%02x.%01x from "
                                 "seize list\n", domain, bus, slot, func);
                }
        }
@@ -1028,20 +942,16 @@ static int pcistub_device_id_remove(int domain, int bus, int slot, int func)
        return err;
 }
-static int pcistub_reg_add(int domain, int bus, int slot, int func,
+static int pcistub_reg_add(int domain, int bus, int slot, int func, int reg,
-                           unsigned int reg, unsigned int size,
+                           int size, int mask)
-                           unsigned int mask)
 {
        int err = 0;
        struct pcistub_device *psdev;
        struct pci_dev *dev;
        struct config_field *field;
-        if (reg > 0xfff || (size < 4 && (mask >> (size * 8))))
-                return -EINVAL;
        psdev = pcistub_device_find(domain, bus, slot, func);
-        if (!psdev) {
+        if (!psdev || !psdev->dev) {
                err = -ENODEV;
                goto out;
        }
@@ -1065,8 +975,6 @@ static int pcistub_reg_add(int domain, int bus, int slot, int func,
        if (err)
                kfree(field);
 out:
-        if (psdev)
-                pcistub_device_put(psdev);
        return err;
 }
@@ -1087,7 +995,8 @@ out:
                err = count;
        return err;
 }
-static DRIVER_ATTR(new_slot, S_IWUSR, NULL, pcistub_slot_add);
+DRIVER_ATTR(new_slot, S_IWUSR, NULL, pcistub_slot_add);
 static ssize_t pcistub_slot_remove(struct device_driver *drv, const char *buf,
                                   size_t count)
@@ -1106,7 +1015,8 @@ out:
                err = count;
        return err;
 }
-static DRIVER_ATTR(remove_slot, S_IWUSR, NULL, pcistub_slot_remove);
+DRIVER_ATTR(remove_slot, S_IWUSR, NULL, pcistub_slot_remove);
 static ssize_t pcistub_slot_show(struct device_driver *drv, char *buf)
 {
@@ -1120,7 +1030,7 @@ static ssize_t pcistub_slot_show(struct device_driver *drv, char *buf)
                        break;
                count += scnprintf(buf + count, PAGE_SIZE - count,
-                                   "%04x:%02x:%02x.%d\n",
+                                   "%04x:%02x:%02x.%01x\n",
                                   pci_dev_id->domain, pci_dev_id->bus,
                                   PCI_SLOT(pci_dev_id->devfn),
                                   PCI_FUNC(pci_dev_id->devfn));
@@ -1129,7 +1039,8 @@ static ssize_t pcistub_slot_show(struct device_driver *drv, char *buf)
        return count;
 }
-static DRIVER_ATTR(slots, S_IRUSR, pcistub_slot_show, NULL);
+DRIVER_ATTR(slots, S_IRUSR, pcistub_slot_show, NULL);
 static ssize_t pcistub_irq_handler_show(struct device_driver *drv, char *buf)
 {
@@ -1158,7 +1069,8 @@ static ssize_t pcistub_irq_handler_show(struct device_driver *drv, char *buf)
        spin_unlock_irqrestore(&pcistub_devices_lock, flags);
        return count;
 }
-static DRIVER_ATTR(irq_handlers, S_IRUSR, pcistub_irq_handler_show, NULL);
+DRIVER_ATTR(irq_handlers, S_IRUSR, pcistub_irq_handler_show, NULL);
 static ssize_t pcistub_irq_handler_switch(struct device_driver *drv,
                                          const char *buf,
@@ -1171,9 +1083,10 @@ static ssize_t pcistub_irq_handler_switch(struct device_driver *drv,
        err = str_to_slot(buf, &domain, &bus, &slot, &func);
        if (err)
-                return err;
+                goto out;
        psdev = pcistub_device_find(domain, bus, slot, func);
        if (!psdev)
                goto out;
@@ -1189,14 +1102,11 @@ static ssize_t pcistub_irq_handler_switch(struct device_driver *drv,
        if (dev_data->isr_on)
                dev_data->ack_intr = 1;
 out:
-        if (psdev)
-                pcistub_device_put(psdev);
        if (!err)
                err = count;
        return err;
 }
-static DRIVER_ATTR(irq_handler_state, S_IWUSR, NULL,
+DRIVER_ATTR(irq_handler_state, S_IWUSR, NULL, pcistub_irq_handler_switch);
-                   pcistub_irq_handler_switch);
 static ssize_t pcistub_quirk_add(struct device_driver *drv, const char *buf,
                                 size_t count)
@@ -1260,8 +1170,8 @@ out:
        return count;
 }
-static DRIVER_ATTR(quirks, S_IRUSR | S_IWUSR, pcistub_quirk_show,
-                   pcistub_quirk_add);
+DRIVER_ATTR(quirks, S_IRUSR | S_IWUSR, pcistub_quirk_show, pcistub_quirk_add);
 static ssize_t permissive_add(struct device_driver *drv, const char *buf,
                              size_t count)
@@ -1270,17 +1180,18 @@ static ssize_t permissive_add(struct device_driver *drv, const char *buf,
        int err;
        struct pcistub_device *psdev;
        struct xen_pcibk_dev_data *dev_data;
        err = str_to_slot(buf, &domain, &bus, &slot, &func);
        if (err)
                goto out;
        psdev = pcistub_device_find(domain, bus, slot, func);
        if (!psdev) {
                err = -ENODEV;
                goto out;
        }
+        if (!psdev->dev) {
+                err = -ENODEV;
+                goto release;
+        }
        dev_data = pci_get_drvdata(psdev->dev);
        /* the driver data for a device should never be null at this point */
        if (!dev_data) {
@@ -1325,8 +1236,8 @@ static ssize_t permissive_show(struct device_driver *drv, char *buf)
        spin_unlock_irqrestore(&pcistub_devices_lock, flags);
        return count;
 }
-static DRIVER_ATTR(permissive, S_IRUSR | S_IWUSR, permissive_show,
-                   permissive_add);
+DRIVER_ATTR(permissive, S_IRUSR | S_IWUSR, permissive_show, permissive_add);
 static void pcistub_exit(void)
 {
@@ -1358,51 +1269,22 @@ static int __init pcistub_init(void)
                        err = sscanf(pci_devs_to_hide + pos,
                                     " (%x:%x:%x.%x) %n",
                                     &domain, &bus, &slot, &func, &parsed);
-                        switch (err) {
+                        if (err != 4) {
-                        case 3:
-                                func = -1;
-                                sscanf(pci_devs_to_hide + pos,
-                                       " (%x:%x:%x.*) %n",
-                                       &domain, &bus, &slot, &parsed);
-                                break;
-                        case 2:
-                                slot = func = -1;
-                                sscanf(pci_devs_to_hide + pos,
-                                       " (%x:%x:*.*) %n",
-                                       &domain, &bus, &parsed);
-                                break;
-                        }
-                        if (!parsed) {
                                domain = 0;
                                err = sscanf(pci_devs_to_hide + pos,
                                             " (%x:%x.%x) %n",
                                             &bus, &slot, &func, &parsed);
-                                switch (err) {
+                                if (err != 3)
-                                case 2:
+                                        goto parse_error;
-                                        func = -1;
-                                        sscanf(pci_devs_to_hide + pos,
-                                               " (%x:%x.*) %n",
-                                               &bus, &slot, &parsed);
-                                        break;
-                                case 1:
-                                        slot = func = -1;
-                                        sscanf(pci_devs_to_hide + pos,
-                                               " (%x:*.*) %n",
-                                               &bus, &parsed);
-                                        break;
-                                }
                        }
-                        if (parsed <= 0)
-                                goto parse_error;
                        err = pcistub_device_id_add(domain, bus, slot, func);
                        if (err)
                                goto out;
+                        /* if parsed<=0, we've reached the end of the string */
                        pos += parsed;
-                } while (pci_devs_to_hide[pos]);
+                } while (parsed > 0 && pci_devs_to_hide[pos]);
        }
        /* If we're the first PCI Device Driver to register, we're the
@@ -1492,4 +1374,3 @@ module_init(xen_pcibk_init);
 module_exit(xen_pcibk_cleanup);
 MODULE_LICENSE("Dual BSD/GPL");
-MODULE_ALIAS("xen-backend:pci");
diff --git a/drivers/xen/xen-pciback/pciback.h b/drivers/xen/xen-pciback/pciback.h
index a7def010eba..a0e131a8150 100644
--- a/drivers/xen/xen-pciback/pciback.h
+++ b/drivers/xen/xen-pciback/pciback.h
@@ -15,8 +15,6 @@
 #include <linux/atomic.h>
 #include <xen/interface/io/pciif.h>
-#define DRV_NAME        "xen-pciback"
 struct pci_dev_entry {
        struct list_head list;
        struct pci_dev *dev;
@@ -29,7 +27,7 @@ struct pci_dev_entry {
 struct xen_pcibk_device {
        void *pci_dev_data;
-        struct mutex dev_lock;
+        spinlock_t dev_lock;
        struct xenbus_device *xdev;
        struct xenbus_watch be_watch;
        u8 be_watching;
@@ -41,7 +39,6 @@ struct xen_pcibk_device {
 struct xen_pcibk_dev_data {
        struct list_head config_fields;
-        struct pci_saved_state *pci_saved_state;
        unsigned int permissive:1;
        unsigned int warned_on_write:1;
        unsigned int enable_intx:1;
@@ -92,7 +89,7 @@ typedef int (*publish_pci_root_cb) (struct xen_pcibk_device *pdev,
 *  passthrough - BDFs are exactly like in the host.
 */
 struct xen_pcibk_backend {
-        const char *name;
+        char *name;
        int (*init)(struct xen_pcibk_device *pdev);
        void (*free)(struct xen_pcibk_device *pdev);
        int (*find)(struct pci_dev *pcidev, struct xen_pcibk_device *pdev,
@@ -107,9 +104,9 @@ struct xen_pcibk_backend {
                               unsigned int devfn);
 };
-extern const struct xen_pcibk_backend xen_pcibk_vpci_backend;
+extern struct xen_pcibk_backend xen_pcibk_vpci_backend;
-extern const struct xen_pcibk_backend xen_pcibk_passthrough_backend;
+extern struct xen_pcibk_backend xen_pcibk_passthrough_backend;
-extern const struct xen_pcibk_backend *xen_pcibk_backend;
+extern struct xen_pcibk_backend *xen_pcibk_backend;
 static inline int xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
                                        struct pci_dev *dev,
@@ -119,14 +116,13 @@ static inline int xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
        if (xen_pcibk_backend && xen_pcibk_backend->add)
                return xen_pcibk_backend->add(pdev, dev, devid, publish_cb);
        return -1;
-}
+};
 static inline void xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
                                             struct pci_dev *dev)
 {
        if (xen_pcibk_backend && xen_pcibk_backend->free)
                return xen_pcibk_backend->release(pdev, dev);
-}
+};
 static inline struct pci_dev *
 xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev, unsigned int domain,
@@ -135,8 +131,7 @@ xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev, unsigned int domain,
        if (xen_pcibk_backend && xen_pcibk_backend->get)
                return xen_pcibk_backend->get(pdev, domain, bus, devfn);
        return NULL;
-}
+};
 /**
 * Add for domain0 PCIE-AER handling. Get guest domain/bus/devfn in xen_pcibk
 * before sending aer request to pcifront, so that guest could identify
@@ -153,29 +148,25 @@ static inline int xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
                return xen_pcibk_backend->find(pcidev, pdev, domain, bus,
                                               devfn);
        return -1;
-}
+};
 static inline int xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
 {
        if (xen_pcibk_backend && xen_pcibk_backend->init)
                return xen_pcibk_backend->init(pdev);
        return -1;
-}
+};
 static inline int xen_pcibk_publish_pci_roots(struct xen_pcibk_device *pdev,
                                              publish_pci_root_cb cb)
 {
        if (xen_pcibk_backend && xen_pcibk_backend->publish)
                return xen_pcibk_backend->publish(pdev, cb);
        return -1;
-}
+};
 static inline void xen_pcibk_release_devices(struct xen_pcibk_device *pdev)
 {
        if (xen_pcibk_backend && xen_pcibk_backend->free)
                return xen_pcibk_backend->free(pdev);
-}
+};
 /* Handles events from front-end */
 irqreturn_t xen_pcibk_handle_event(int irq, void *dev_id);
 void xen_pcibk_do_op(struct work_struct *data);
diff --git a/drivers/xen/xen-pciback/pciback_ops.c b/drivers/xen/xen-pciback/pciback_ops.c
index 97f5d264c31..8c95c3415b7 100644
--- a/drivers/xen/xen-pciback/pciback_ops.c
+++ b/drivers/xen/xen-pciback/pciback_ops.c
@@ -10,6 +10,7 @@
 #include <linux/sched.h>
 #include "pciback.h"
+#define DRV_NAME        "xen-pciback"
 int verbose_request;
 module_param(verbose_request, int, 0644);
@@ -234,7 +235,7 @@ int xen_pcibk_enable_msix(struct xen_pcibk_device *pdev,
        if (dev_data)
                dev_data->ack_intr = 0;
-        return result > 0 ? 0 : result;
+        return result;
 }
 static
diff --git a/drivers/xen/xen-pciback/vpci.c b/drivers/xen/xen-pciback/vpci.c
index 0f478ac483c..4a42cfb0959 100644
--- a/drivers/xen/xen-pciback/vpci.c
+++ b/drivers/xen/xen-pciback/vpci.c
@@ -8,15 +8,16 @@
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/pci.h>
-#include <linux/mutex.h>
+#include <linux/spinlock.h>
 #include "pciback.h"
 #define PCI_SLOT_MAX 32
+#define DRV_NAME        "xen-pciback"
 struct vpci_dev_data {
        /* Access to dev_list must be protected by lock */
        struct list_head dev_list[PCI_SLOT_MAX];
-        struct mutex lock;
+        spinlock_t lock;
 };
 static inline struct list_head *list_first(struct list_head *head)
@@ -32,12 +33,13 @@ static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
        struct pci_dev_entry *entry;
        struct pci_dev *dev = NULL;
        struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
+        unsigned long flags;
        if (domain != 0 || bus != 0)
                return NULL;
        if (PCI_SLOT(devfn) < PCI_SLOT_MAX) {
-                mutex_lock(&vpci_dev->lock);
+                spin_lock_irqsave(&vpci_dev->lock, flags);
                list_for_each_entry(entry,
                                    &vpci_dev->dev_list[PCI_SLOT(devfn)],
@@ -48,7 +50,7 @@ static struct pci_dev *__xen_pcibk_get_pci_dev(struct xen_pcibk_device *pdev,
                        }
                }
-                mutex_unlock(&vpci_dev->lock);
+                spin_unlock_irqrestore(&vpci_dev->lock, flags);
        }
        return dev;
 }
@@ -69,6 +71,7 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
        int err = 0, slot, func = -1;
        struct pci_dev_entry *t, *dev_entry;
        struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
+        unsigned long flags;
        if ((dev->class >> 24) == PCI_BASE_CLASS_BRIDGE) {
                err = -EFAULT;
@@ -87,17 +90,11 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
        dev_entry->dev = dev;
-        mutex_lock(&vpci_dev->lock);
+        spin_lock_irqsave(&vpci_dev->lock, flags);
-        /*
-         * Keep multi-function devices together on the virtual PCI bus, except
-         * virtual functions.
-         */
-        if (!dev->is_virtfn) {
-                for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
-                        if (list_empty(&vpci_dev->dev_list[slot]))
-                                continue;
+        /* Keep multi-function devices together on the virtual PCI bus */
+        for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
+                if (!list_empty(&vpci_dev->dev_list[slot])) {
                        t = list_entry(list_first(&vpci_dev->dev_list[slot]),
                                       struct pci_dev_entry, list);
@@ -122,7 +119,7 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
                               pci_name(dev), slot);
                        list_add_tail(&dev_entry->list,
                                      &vpci_dev->dev_list[slot]);
-                        func = dev->is_virtfn ? 0 : PCI_FUNC(dev->devfn);
+                        func = PCI_FUNC(dev->devfn);
                        goto unlock;
                }
        }
@@ -132,7 +129,7 @@ static int __xen_pcibk_add_pci_dev(struct xen_pcibk_device *pdev,
                         "No more space on root virtual PCI bus");
 unlock:
-        mutex_unlock(&vpci_dev->lock);
+        spin_unlock_irqrestore(&vpci_dev->lock, flags);
        /* Publish this device. */
        if (!err)
@@ -148,13 +145,14 @@ static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
        int slot;
        struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
        struct pci_dev *found_dev = NULL;
+        unsigned long flags;
-        mutex_lock(&vpci_dev->lock);
+        spin_lock_irqsave(&vpci_dev->lock, flags);
        for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
-                struct pci_dev_entry *e;
+                struct pci_dev_entry *e, *tmp;
+                list_for_each_entry_safe(e, tmp, &vpci_dev->dev_list[slot],
-                list_for_each_entry(e, &vpci_dev->dev_list[slot], list) {
+                                         list) {
                        if (e->dev == dev) {
                                list_del(&e->list);
                                found_dev = e->dev;
@@ -165,7 +163,7 @@ static void __xen_pcibk_release_pci_dev(struct xen_pcibk_device *pdev,
        }
 out:
-        mutex_unlock(&vpci_dev->lock);
+        spin_unlock_irqrestore(&vpci_dev->lock, flags);
        if (found_dev)
                pcistub_put_pci_dev(found_dev);
@@ -180,7 +178,7 @@ static int __xen_pcibk_init_devices(struct xen_pcibk_device *pdev)
        if (!vpci_dev)
                return -ENOMEM;
-        mutex_init(&vpci_dev->lock);
+        spin_lock_init(&vpci_dev->lock);
        for (slot = 0; slot < PCI_SLOT_MAX; slot++)
                INIT_LIST_HEAD(&vpci_dev->dev_list[slot]);
@@ -224,9 +222,10 @@ static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
        struct pci_dev_entry *entry;
        struct pci_dev *dev = NULL;
        struct vpci_dev_data *vpci_dev = pdev->pci_dev_data;
+        unsigned long flags;
        int found = 0, slot;
-        mutex_lock(&vpci_dev->lock);
+        spin_lock_irqsave(&vpci_dev->lock, flags);
        for (slot = 0; slot < PCI_SLOT_MAX; slot++) {
                list_for_each_entry(entry,
                            &vpci_dev->dev_list[slot],
@@ -244,11 +243,11 @@ static int __xen_pcibk_get_pcifront_dev(struct pci_dev *pcidev,
                        }
                }
        }
-        mutex_unlock(&vpci_dev->lock);
+        spin_unlock_irqrestore(&vpci_dev->lock, flags);
        return found;
 }
-const struct xen_pcibk_backend xen_pcibk_vpci_backend = {
+struct xen_pcibk_backend xen_pcibk_vpci_backend = {
        .name           = "vpci",
        .init           = __xen_pcibk_init_devices,
        .free           = __xen_pcibk_release_devices,
diff --git a/drivers/xen/xen-pciback/xenbus.c b/drivers/xen/xen-pciback/xenbus.c
index 64b11f99eac..978d2c6f5dc 100644
--- a/drivers/xen/xen-pciback/xenbus.c
+++ b/drivers/xen/xen-pciback/xenbus.c
@@ -13,10 +13,11 @@
 #include <asm/xen/pci.h>
 #include "pciback.h"
+#define DRV_NAME        "xen-pciback"
 #define INVALID_EVTCHN_IRQ  (-1)
 struct workqueue_struct *xen_pcibk_wq;
-static bool __read_mostly passthrough;
+static int __read_mostly passthrough;
 module_param(passthrough, bool, S_IRUGO);
 MODULE_PARM_DESC(passthrough,
        "Option to specify how to export PCI topology to guest:\n"\
@@ -43,7 +44,7 @@ static struct xen_pcibk_device *alloc_pdev(struct xenbus_device *xdev)
        pdev->xdev = xdev;
        dev_set_drvdata(&xdev->dev, pdev);
-        mutex_init(&pdev->dev_lock);
+        spin_lock_init(&pdev->dev_lock);
        pdev->sh_info = NULL;
        pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
@@ -61,12 +62,14 @@ out:
 static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev)
 {
-        mutex_lock(&pdev->dev_lock);
+        spin_lock(&pdev->dev_lock);
        /* Ensure the guest can't trigger our handler before removing devices */
        if (pdev->evtchn_irq != INVALID_EVTCHN_IRQ) {
                unbind_from_irqhandler(pdev->evtchn_irq, pdev);
                pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
        }
+        spin_unlock(&pdev->dev_lock);
        /* If the driver domain started an op, make sure we complete it
         * before releasing the shared memory */
@@ -74,11 +77,13 @@ static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev)
        /* Note, the workqueue does not use spinlocks at all.*/
        flush_workqueue(xen_pcibk_wq);
+        spin_lock(&pdev->dev_lock);
        if (pdev->sh_info != NULL) {
                xenbus_unmap_ring_vfree(pdev->xdev, pdev->sh_info);
                pdev->sh_info = NULL;
        }
-        mutex_unlock(&pdev->dev_lock);
+        spin_unlock(&pdev->dev_lock);
 }
 static void free_pdev(struct xen_pcibk_device *pdev)
@@ -115,7 +120,9 @@ static int xen_pcibk_do_attach(struct xen_pcibk_device *pdev, int gnt_ref,
                goto out;
        }
+        spin_lock(&pdev->dev_lock);
        pdev->sh_info = vaddr;
+        spin_unlock(&pdev->dev_lock);
        err = bind_interdomain_evtchn_to_irqhandler(
                pdev->xdev->otherend_id, remote_evtchn, xen_pcibk_handle_event,
@@ -125,7 +132,10 @@ static int xen_pcibk_do_attach(struct xen_pcibk_device *pdev, int gnt_ref,
                                 "Error binding event channel to IRQ");
                goto out;
        }
+        spin_lock(&pdev->dev_lock);
        pdev->evtchn_irq = err;
+        spin_unlock(&pdev->dev_lock);
        err = 0;
        dev_dbg(&pdev->xdev->dev, "Attached!\n");
@@ -140,7 +150,6 @@ static int xen_pcibk_attach(struct xen_pcibk_device *pdev)
        char *magic = NULL;
-        mutex_lock(&pdev->dev_lock);
        /* Make sure we only do this setup once */
        if (xenbus_read_driver_state(pdev->xdev->nodename) !=
            XenbusStateInitialised)
@@ -167,7 +176,7 @@ static int xen_pcibk_attach(struct xen_pcibk_device *pdev)
        if (magic == NULL || strcmp(magic, XEN_PCI_MAGIC) != 0) {
                xenbus_dev_fatal(pdev->xdev, -EFAULT,
                                 "version mismatch (%s/%s) with pcifront - "
-                                 "halting " DRV_NAME,
+                                 "halting xen_pcibk",
                                 magic, XEN_PCI_MAGIC);
                goto out;
        }
@@ -185,7 +194,6 @@ static int xen_pcibk_attach(struct xen_pcibk_device *pdev)
        dev_dbg(&pdev->xdev->dev, "Connected? %d\n", err);
 out:
-        mutex_unlock(&pdev->dev_lock);
        kfree(magic);
@@ -206,7 +214,6 @@ static int xen_pcibk_publish_pci_dev(struct xen_pcibk_device *pdev,
                goto out;
        }
-        /* Note: The PV protocol uses %02x, don't change it */
        err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str,
                            "%04x:%02x:%02x.%02x", domain, bus,
                            PCI_SLOT(devfn), PCI_FUNC(devfn));
@@ -230,7 +237,7 @@ static int xen_pcibk_export_device(struct xen_pcibk_device *pdev,
                err = -EINVAL;
                xenbus_dev_fatal(pdev->xdev, err,
                                 "Couldn't locate PCI device "
-                                 "(%04x:%02x:%02x.%d)! "
+                                 "(%04x:%02x:%02x.%01x)! "
                                 "perhaps already in-use?",
                                 domain, bus, slot, func);
                goto out;
@@ -244,8 +251,8 @@ static int xen_pcibk_export_device(struct xen_pcibk_device *pdev,
        dev_dbg(&dev->dev, "registering for %d\n", pdev->xdev->otherend_id);
        if (xen_register_device_domain_owner(dev,
                                             pdev->xdev->otherend_id) != 0) {
-                dev_err(&dev->dev, "Stealing ownership from dom%d.\n",
+                dev_err(&dev->dev, "device has been assigned to another " \
-                        xen_find_device_domain_owner(dev));
+                        "domain! Over-writting the ownership, but beware.\n");
                xen_unregister_device_domain_owner(dev);
                xen_register_device_domain_owner(dev, pdev->xdev->otherend_id);
        }
@@ -275,7 +282,7 @@ static int xen_pcibk_remove_device(struct xen_pcibk_device *pdev,
        if (!dev) {
                err = -EINVAL;
                dev_dbg(&pdev->xdev->dev, "Couldn't locate PCI device "
-                        "(%04x:%02x:%02x.%d)! not owned by this domain\n",
+                        "(%04x:%02x:%02x.%01x)! not owned by this domain\n",
                        domain, bus, slot, func);
                goto out;
        }
@@ -362,7 +369,6 @@ static int xen_pcibk_reconfigure(struct xen_pcibk_device *pdev)
        dev_dbg(&pdev->xdev->dev, "Reconfiguring device ...\n");
-        mutex_lock(&pdev->dev_lock);
        /* Make sure we only reconfigure once */
        if (xenbus_read_driver_state(pdev->xdev->nodename) !=
            XenbusStateReconfiguring)
@@ -500,7 +506,6 @@ static int xen_pcibk_reconfigure(struct xen_pcibk_device *pdev)
        }
 out:
-        mutex_unlock(&pdev->dev_lock);
        return 0;
 }
@@ -557,7 +562,6 @@ static int xen_pcibk_setup_backend(struct xen_pcibk_device *pdev)
        char dev_str[64];
        char state_str[64];
-        mutex_lock(&pdev->dev_lock);
        /* It's possible we could get the call to setup twice, so make sure
         * we're not already connected.
         */
@@ -638,10 +642,10 @@ static int xen_pcibk_setup_backend(struct xen_pcibk_device *pdev)
                                 "Error switching to initialised state!");
 out:
-        mutex_unlock(&pdev->dev_lock);
        if (!err)
                /* see if pcifront is already configured (if not, we'll wait) */
                xen_pcibk_attach(pdev);
        return err;
 }
@@ -706,18 +710,21 @@ static int xen_pcibk_xenbus_remove(struct xenbus_device *dev)
        return 0;
 }
-static const struct xenbus_device_id xen_pcibk_ids[] = {
+static const struct xenbus_device_id xenpci_ids[] = {
        {"pci"},
        {""},
 };
-static DEFINE_XENBUS_DRIVER(xen_pcibk, DRV_NAME,
+static struct xenbus_driver xenbus_xen_pcibk_driver = {
+        .name                   = DRV_NAME,
+        .owner                  = THIS_MODULE,
+        .ids                    = xenpci_ids,
        .probe                  = xen_pcibk_xenbus_probe,
        .remove                 = xen_pcibk_xenbus_remove,
        .otherend_changed       = xen_pcibk_frontend_changed,
-);
+};
-const struct xen_pcibk_backend *__read_mostly xen_pcibk_backend;
+struct xen_pcibk_backend *xen_pcibk_backend;
 int __init xen_pcibk_xenbus_register(void)
 {
@@ -731,11 +738,11 @@ int __init xen_pcibk_xenbus_register(void)
        if (passthrough)
                xen_pcibk_backend = &xen_pcibk_passthrough_backend;
        pr_info(DRV_NAME ": backend is %s\n", xen_pcibk_backend->name);
-        return xenbus_register_backend(&xen_pcibk_driver);
+        return xenbus_register_backend(&xenbus_xen_pcibk_driver);
 }
 void __exit xen_pcibk_xenbus_unregister(void)
 {
        destroy_workqueue(xen_pcibk_wq);
-        xenbus_unregister_driver(&xen_pcibk_driver);
+        xenbus_unregister_driver(&xenbus_xen_pcibk_driver);
 }
diff --git a/drivers/xen/xen-selfballoon.c b/drivers/xen/xen-selfballoon.c
index 2552d3e0a70..6ea852e2516 100644
--- a/drivers/xen/xen-selfballoon.c
+++ b/drivers/xen/xen-selfballoon.c
@@ -68,13 +68,10 @@
 */
 #include <linux/kernel.h>
-#include <linux/bootmem.h>
-#include <linux/swap.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
-#include <linux/device.h>
 #include <xen/balloon.h>
 #include <xen/tmem.h>
 #include <xen/xen.h>
@@ -96,21 +93,6 @@ static unsigned int selfballoon_uphysteresis __read_mostly = 1;
 /* In HZ, controls frequency of worker invocation. */
 static unsigned int selfballoon_interval __read_mostly = 5;
-/*
- * Minimum usable RAM in MB for selfballooning target for balloon.
- * If non-zero, it is added to totalreserve_pages and self-ballooning
- * will not balloon below the sum.  If zero, a piecewise linear function
- * is calculated as a minimum and added to totalreserve_pages.  Note that
- * setting this value indiscriminately may cause OOMs and crashes.
- */
-static unsigned int selfballoon_min_usable_mb;
-/*
- * Amount of RAM in MB to add to the target number of pages.
- * Can be used to reserve some more room for caches and the like.
- */
-static unsigned int selfballoon_reserved_mb;
 static void selfballoon_process(struct work_struct *work);
 static DECLARE_DELAYED_WORK(selfballoon_worker, selfballoon_process);
@@ -207,24 +189,20 @@ static int __init xen_selfballooning_setup(char *s)
 __setup("selfballooning", xen_selfballooning_setup);
 #endif /* CONFIG_FRONTSWAP */
-#define MB2PAGES(mb)    ((mb) << (20 - PAGE_SHIFT))
 /*
 * Use current balloon size, the goal (vm_committed_as), and hysteresis
 * parameters to set a new target balloon size
 */
 static void selfballoon_process(struct work_struct *work)
 {
-        unsigned long cur_pages, goal_pages, tgt_pages, floor_pages;
+        unsigned long cur_pages, goal_pages, tgt_pages;
-        unsigned long useful_pages;
        bool reset_timer = false;
        if (xen_selfballooning_enabled) {
-                cur_pages = totalram_pages;
+                cur_pages = balloon_stats.current_pages;
                tgt_pages = cur_pages; /* default is no change */
-                goal_pages = vm_memory_committed() +
+                goal_pages = percpu_counter_read_positive(&vm_committed_as) +
-                                totalreserve_pages +
+                        balloon_stats.current_pages - totalram_pages;
-                                MB2PAGES(selfballoon_reserved_mb);
 #ifdef CONFIG_FRONTSWAP
                /* allow space for frontswap pages to be repatriated */
                if (frontswap_selfshrinking && frontswap_enabled)
@@ -239,26 +217,7 @@ static void selfballoon_process(struct work_struct *work)
                                ((goal_pages - cur_pages) /
                                  selfballoon_uphysteresis);
                /* else if cur_pages == goal_pages, no change */
-                useful_pages = max_pfn - totalreserve_pages;
+                balloon_set_new_target(tgt_pages);
-                if (selfballoon_min_usable_mb != 0)
-                        floor_pages = totalreserve_pages +
-                                        MB2PAGES(selfballoon_min_usable_mb);
-                /* piecewise linear function ending in ~3% slope */
-                else if (useful_pages < MB2PAGES(16))
-                        floor_pages = max_pfn; /* not worth ballooning */
-                else if (useful_pages < MB2PAGES(64))
-                        floor_pages = totalreserve_pages + MB2PAGES(16) +
-                                        ((useful_pages - MB2PAGES(16)) >> 1);
-                else if (useful_pages < MB2PAGES(512))
-                        floor_pages = totalreserve_pages + MB2PAGES(40) +
-                                        ((useful_pages - MB2PAGES(40)) >> 3);
-                else /* useful_pages >= MB2PAGES(512) */
-                        floor_pages = totalreserve_pages + MB2PAGES(99) +
-                                        ((useful_pages - MB2PAGES(99)) >> 5);
-                if (tgt_pages < floor_pages)
-                        tgt_pages = floor_pages;
-                balloon_set_new_target(tgt_pages +
-                        balloon_stats.current_pages - totalram_pages);
                reset_timer = true;
        }
 #ifdef CONFIG_FRONTSWAP
@@ -274,20 +233,21 @@ static void selfballoon_process(struct work_struct *work)
 #ifdef CONFIG_SYSFS
+#include <linux/sysdev.h>
 #include <linux/capability.h>
 #define SELFBALLOON_SHOW(name, format, args...)                         \
-        static ssize_t show_##name(struct device *dev,  \
+        static ssize_t show_##name(struct sys_device *dev,      \
-                                          struct device_attribute *attr, \
+                                           struct sysdev_attribute *attr, \
-                                          char *buf) \
+                                           char *buf) \
        { \
                return sprintf(buf, format, ##args); \
        }
 SELFBALLOON_SHOW(selfballooning, "%d\n", xen_selfballooning_enabled);
-static ssize_t store_selfballooning(struct device *dev,
+static ssize_t store_selfballooning(struct sys_device *dev,
-                            struct device_attribute *attr,
+                            struct sysdev_attribute *attr,
                            const char *buf,
                            size_t count)
 {
@@ -310,13 +270,13 @@ static ssize_t store_selfballooning(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(selfballooning, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(selfballooning, S_IRUGO | S_IWUSR,
                   show_selfballooning, store_selfballooning);
 SELFBALLOON_SHOW(selfballoon_interval, "%d\n", selfballoon_interval);
-static ssize_t store_selfballoon_interval(struct device *dev,
+static ssize_t store_selfballoon_interval(struct sys_device *dev,
-                                          struct device_attribute *attr,
+                                          struct sysdev_attribute *attr,
                                          const char *buf,
                                          size_t count)
 {
@@ -332,13 +292,13 @@ static ssize_t store_selfballoon_interval(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(selfballoon_interval, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(selfballoon_interval, S_IRUGO | S_IWUSR,
                   show_selfballoon_interval, store_selfballoon_interval);
 SELFBALLOON_SHOW(selfballoon_downhys, "%d\n", selfballoon_downhysteresis);
-static ssize_t store_selfballoon_downhys(struct device *dev,
+static ssize_t store_selfballoon_downhys(struct sys_device *dev,
-                                         struct device_attribute *attr,
+                                         struct sysdev_attribute *attr,
                                         const char *buf,
                                         size_t count)
 {
@@ -354,14 +314,14 @@ static ssize_t store_selfballoon_downhys(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(selfballoon_downhysteresis, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(selfballoon_downhysteresis, S_IRUGO | S_IWUSR,
                   show_selfballoon_downhys, store_selfballoon_downhys);
 SELFBALLOON_SHOW(selfballoon_uphys, "%d\n", selfballoon_uphysteresis);
-static ssize_t store_selfballoon_uphys(struct device *dev,
+static ssize_t store_selfballoon_uphys(struct sys_device *dev,
-                                       struct device_attribute *attr,
+                                       struct sysdev_attribute *attr,
                                       const char *buf,
                                       size_t count)
 {
@@ -377,63 +337,14 @@ static ssize_t store_selfballoon_uphys(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(selfballoon_uphysteresis, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(selfballoon_uphysteresis, S_IRUGO | S_IWUSR,
                   show_selfballoon_uphys, store_selfballoon_uphys);
-SELFBALLOON_SHOW(selfballoon_min_usable_mb, "%d\n",
-                                selfballoon_min_usable_mb);
-static ssize_t store_selfballoon_min_usable_mb(struct device *dev,
-                                               struct device_attribute *attr,
-                                               const char *buf,
-                                               size_t count)
-{
-        unsigned long val;
-        int err;
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        err = strict_strtoul(buf, 10, &val);
-        if (err || val == 0)
-                return -EINVAL;
-        selfballoon_min_usable_mb = val;
-        return count;
-}
-static DEVICE_ATTR(selfballoon_min_usable_mb, S_IRUGO | S_IWUSR,
-                   show_selfballoon_min_usable_mb,
-                   store_selfballoon_min_usable_mb);
-SELFBALLOON_SHOW(selfballoon_reserved_mb, "%d\n",
-                                selfballoon_reserved_mb);
-static ssize_t store_selfballoon_reserved_mb(struct device *dev,
-                                             struct device_attribute *attr,
-                                             const char *buf,
-                                             size_t count)
-{
-        unsigned long val;
-        int err;
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        err = strict_strtoul(buf, 10, &val);
-        if (err || val == 0)
-                return -EINVAL;
-        selfballoon_reserved_mb = val;
-        return count;
-}
-static DEVICE_ATTR(selfballoon_reserved_mb, S_IRUGO | S_IWUSR,
-                   show_selfballoon_reserved_mb,
-                   store_selfballoon_reserved_mb);
 #ifdef CONFIG_FRONTSWAP
 SELFBALLOON_SHOW(frontswap_selfshrinking, "%d\n", frontswap_selfshrinking);
-static ssize_t store_frontswap_selfshrinking(struct device *dev,
+static ssize_t store_frontswap_selfshrinking(struct sys_device *dev,
-                                             struct device_attribute *attr,
+                                             struct sysdev_attribute *attr,
                                             const char *buf,
                                             size_t count)
 {
@@ -455,13 +366,13 @@ static ssize_t store_frontswap_selfshrinking(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(frontswap_selfshrinking, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(frontswap_selfshrinking, S_IRUGO | S_IWUSR,
                   show_frontswap_selfshrinking, store_frontswap_selfshrinking);
 SELFBALLOON_SHOW(frontswap_inertia, "%d\n", frontswap_inertia);
-static ssize_t store_frontswap_inertia(struct device *dev,
+static ssize_t store_frontswap_inertia(struct sys_device *dev,
-                                       struct device_attribute *attr,
+                                       struct sysdev_attribute *attr,
                                       const char *buf,
                                       size_t count)
 {
@@ -478,13 +389,13 @@ static ssize_t store_frontswap_inertia(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(frontswap_inertia, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(frontswap_inertia, S_IRUGO | S_IWUSR,
                   show_frontswap_inertia, store_frontswap_inertia);
 SELFBALLOON_SHOW(frontswap_hysteresis, "%d\n", frontswap_hysteresis);
-static ssize_t store_frontswap_hysteresis(struct device *dev,
+static ssize_t store_frontswap_hysteresis(struct sys_device *dev,
-                                          struct device_attribute *attr,
+                                          struct sysdev_attribute *attr,
                                          const char *buf,
                                          size_t count)
 {
@@ -500,38 +411,36 @@ static ssize_t store_frontswap_hysteresis(struct device *dev,
        return count;
 }
-static DEVICE_ATTR(frontswap_hysteresis, S_IRUGO | S_IWUSR,
+static SYSDEV_ATTR(frontswap_hysteresis, S_IRUGO | S_IWUSR,
                   show_frontswap_hysteresis, store_frontswap_hysteresis);
 #endif /* CONFIG_FRONTSWAP */
 static struct attribute *selfballoon_attrs[] = {
-        &dev_attr_selfballooning.attr,
+        &attr_selfballooning.attr,
-        &dev_attr_selfballoon_interval.attr,
+        &attr_selfballoon_interval.attr,
-        &dev_attr_selfballoon_downhysteresis.attr,
+        &attr_selfballoon_downhysteresis.attr,
-        &dev_attr_selfballoon_uphysteresis.attr,
+        &attr_selfballoon_uphysteresis.attr,
-        &dev_attr_selfballoon_min_usable_mb.attr,
-        &dev_attr_selfballoon_reserved_mb.attr,
 #ifdef CONFIG_FRONTSWAP
-        &dev_attr_frontswap_selfshrinking.attr,
+        &attr_frontswap_selfshrinking.attr,
-        &dev_attr_frontswap_hysteresis.attr,
+        &attr_frontswap_hysteresis.attr,
-        &dev_attr_frontswap_inertia.attr,
+        &attr_frontswap_inertia.attr,
 #endif
        NULL
 };
-static const struct attribute_group selfballoon_group = {
+static struct attribute_group selfballoon_group = {
        .name = "selfballoon",
        .attrs = selfballoon_attrs
 };
 #endif
-int register_xen_selfballooning(struct device *dev)
+int register_xen_selfballooning(struct sys_device *sysdev)
 {
        int error = -1;
 #ifdef CONFIG_SYSFS
-        error = sysfs_create_group(&dev->kobj, &selfballoon_group);
+        error = sysfs_create_group(&sysdev->kobj, &selfballoon_group);
 #endif
        return error;
 }
diff --git a/drivers/xen/xenbus/Makefile b/drivers/xen/xenbus/Makefile
index 31e2e9050c7..8dca685358b 100644
--- a/drivers/xen/xenbus/Makefile
+++ b/drivers/xen/xenbus/Makefile
@@ -1,5 +1,4 @@
 obj-y   += xenbus.o
-obj-y   += xenbus_dev_frontend.o
 xenbus-objs =
 xenbus-objs += xenbus_client.o
@@ -10,5 +9,4 @@ xenbus-objs += xenbus_probe.o
 xenbus-be-objs-$(CONFIG_XEN_BACKEND) += xenbus_probe_backend.o
 xenbus-objs += $(xenbus-be-objs-y)
-obj-$(CONFIG_XEN_BACKEND) += xenbus_dev_backend.o
 obj-$(CONFIG_XEN_XENBUS_FRONTEND) += xenbus_probe_frontend.o
diff --git a/drivers/xen/xenbus/xenbus_client.c b/drivers/xen/xenbus/xenbus_client.c
index bcf3ba4a6ec..cdacf923e07 100644
--- a/drivers/xen/xenbus/xenbus_client.c
+++ b/drivers/xen/xenbus/xenbus_client.c
@@ -32,39 +32,13 @@
 #include <linux/slab.h>
 #include <linux/types.h>
-#include <linux/spinlock.h>
 #include <linux/vmalloc.h>
-#include <linux/export.h>
 #include <asm/xen/hypervisor.h>
-#include <asm/xen/page.h>
 #include <xen/interface/xen.h>
 #include <xen/interface/event_channel.h>
-#include <xen/balloon.h>
 #include <xen/events.h>
 #include <xen/grant_table.h>
 #include <xen/xenbus.h>
-#include <xen/xen.h>
-#include "xenbus_probe.h"
-struct xenbus_map_node {
-        struct list_head next;
-        union {
-                struct vm_struct *area; /* PV */
-                struct page *page;     /* HVM */
-        };
-        grant_handle_t handle;
-};
-static DEFINE_SPINLOCK(xenbus_valloc_lock);
-static LIST_HEAD(xenbus_valloc_pages);
-struct xenbus_ring_ops {
-        int (*map)(struct xenbus_device *dev, int gnt, void **vaddr);
-        int (*unmap)(struct xenbus_device *dev, void *vaddr);
-};
-static const struct xenbus_ring_ops *ring_ops __read_mostly;
 const char *xenbus_strstate(enum xenbus_state state)
 {
@@ -460,93 +434,39 @@ EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
 */
 int xenbus_map_ring_valloc(struct xenbus_device *dev, int gnt_ref, void **vaddr)
 {
-        return ring_ops->map(dev, gnt_ref, vaddr);
-}
-EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
-static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
-                                     int gnt_ref, void **vaddr)
-{
        struct gnttab_map_grant_ref op = {
-                .flags = GNTMAP_host_map | GNTMAP_contains_pte,
+                .flags = GNTMAP_host_map,
                .ref   = gnt_ref,
                .dom   = dev->otherend_id,
        };
-        struct xenbus_map_node *node;
        struct vm_struct *area;
-        pte_t *pte;
        *vaddr = NULL;
-        node = kzalloc(sizeof(*node), GFP_KERNEL);
+        area = xen_alloc_vm_area(PAGE_SIZE);
-        if (!node)
+        if (!area)
                return -ENOMEM;
-        area = alloc_vm_area(PAGE_SIZE, &pte);
+        op.host_addr = (unsigned long)area->addr;
-        if (!area) {
-                kfree(node);
-                return -ENOMEM;
-        }
-        op.host_addr = arbitrary_virt_to_machine(pte).maddr;
-        gnttab_batch_map(&op, 1);
+        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
+                BUG();
        if (op.status != GNTST_okay) {
-                free_vm_area(area);
+                xen_free_vm_area(area);
-                kfree(node);
                xenbus_dev_fatal(dev, op.status,
                                 "mapping in shared page %d from domain %d",
                                 gnt_ref, dev->otherend_id);
                return op.status;
        }
-        node->handle = op.handle;
+        /* Stuff the handle in an unused field */
-        node->area = area;
+        area->phys_addr = (unsigned long)op.handle;
-        spin_lock(&xenbus_valloc_lock);
-        list_add(&node->next, &xenbus_valloc_pages);
-        spin_unlock(&xenbus_valloc_lock);
        *vaddr = area->addr;
        return 0;
 }
+EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
-static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
-                                      int gnt_ref, void **vaddr)
-{
-        struct xenbus_map_node *node;
-        int err;
-        void *addr;
-        *vaddr = NULL;
-        node = kzalloc(sizeof(*node), GFP_KERNEL);
-        if (!node)
-                return -ENOMEM;
-        err = alloc_xenballooned_pages(1, &node->page, false /* lowmem */);
-        if (err)
-                goto out_err;
-        addr = pfn_to_kaddr(page_to_pfn(node->page));
-        err = xenbus_map_ring(dev, gnt_ref, &node->handle, addr);
-        if (err)
-                goto out_err;
-        spin_lock(&xenbus_valloc_lock);
-        list_add(&node->next, &xenbus_valloc_pages);
-        spin_unlock(&xenbus_valloc_lock);
-        *vaddr = addr;
-        return 0;
- out_err:
-        free_xenballooned_pages(1, &node->page);
-        kfree(node);
-        return err;
-}
 /**
@@ -566,12 +486,15 @@ static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
 int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
                    grant_handle_t *handle, void *vaddr)
 {
-        struct gnttab_map_grant_ref op;
+        struct gnttab_map_grant_ref op = {
+                .host_addr = (unsigned long)vaddr,
-        gnttab_set_map_op(&op, (unsigned long)vaddr, GNTMAP_host_map, gnt_ref,
+                .flags     = GNTMAP_host_map,
-                          dev->otherend_id);
+                .ref       = gnt_ref,
+                .dom       = dev->otherend_id,
+        };
-        gnttab_batch_map(&op, 1);
+        if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
+                BUG();
        if (op.status != GNTST_okay) {
                xenbus_dev_fatal(dev, op.status,
@@ -599,87 +522,46 @@ EXPORT_SYMBOL_GPL(xenbus_map_ring);
 */
 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
 {
-        return ring_ops->unmap(dev, vaddr);
+        struct vm_struct *area;
-}
-EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
-static int xenbus_unmap_ring_vfree_pv(struct xenbus_device *dev, void *vaddr)
-{
-        struct xenbus_map_node *node;
        struct gnttab_unmap_grant_ref op = {
                .host_addr = (unsigned long)vaddr,
        };
-        unsigned int level;
+        /* It'd be nice if linux/vmalloc.h provided a find_vm_area(void *addr)
-        spin_lock(&xenbus_valloc_lock);
+         * method so that we don't have to muck with vmalloc internals here.
-        list_for_each_entry(node, &xenbus_valloc_pages, next) {
+         * We could force the user to hang on to their struct vm_struct from
-                if (node->area->addr == vaddr) {
+         * xenbus_map_ring_valloc, but these 6 lines considerably simplify
-                        list_del(&node->next);
+         * this API.
-                        goto found;
+         */
-                }
+        read_lock(&vmlist_lock);
+        for (area = vmlist; area != NULL; area = area->next) {
+                if (area->addr == vaddr)
+                        break;
        }
-        node = NULL;
+        read_unlock(&vmlist_lock);
- found:
-        spin_unlock(&xenbus_valloc_lock);
-        if (!node) {
+        if (!area) {
                xenbus_dev_error(dev, -ENOENT,
                                 "can't find mapped virtual address %p", vaddr);
                return GNTST_bad_virt_addr;
        }
-        op.handle = node->handle;
+        op.handle = (grant_handle_t)area->phys_addr;
-        op.host_addr = arbitrary_virt_to_machine(
-                lookup_address((unsigned long)vaddr, &level)).maddr;
        if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
                BUG();
        if (op.status == GNTST_okay)
-                free_vm_area(node->area);
+                xen_free_vm_area(area);
        else
                xenbus_dev_error(dev, op.status,
                                 "unmapping page at handle %d error %d",
-                                 node->handle, op.status);
+                                 (int16_t)area->phys_addr, op.status);
-        kfree(node);
        return op.status;
 }
+EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
-static int xenbus_unmap_ring_vfree_hvm(struct xenbus_device *dev, void *vaddr)
-{
-        int rv;
-        struct xenbus_map_node *node;
-        void *addr;
-        spin_lock(&xenbus_valloc_lock);
-        list_for_each_entry(node, &xenbus_valloc_pages, next) {
-                addr = pfn_to_kaddr(page_to_pfn(node->page));
-                if (addr == vaddr) {
-                        list_del(&node->next);
-                        goto found;
-                }
-        }
-        node = addr = NULL;
- found:
-        spin_unlock(&xenbus_valloc_lock);
-        if (!node) {
-                xenbus_dev_error(dev, -ENOENT,
-                                 "can't find mapped virtual address %p", vaddr);
-                return GNTST_bad_virt_addr;
-        }
-        rv = xenbus_unmap_ring(dev, node->handle, addr);
-        if (!rv)
-                free_xenballooned_pages(1, &node->page);
-        else
-                WARN(1, "Leaking %p\n", vaddr);
-        kfree(node);
-        return rv;
-}
 /**
 * xenbus_unmap_ring
@@ -694,9 +576,10 @@ static int xenbus_unmap_ring_vfree_hvm(struct xenbus_device *dev, void *vaddr)
 int xenbus_unmap_ring(struct xenbus_device *dev,
                      grant_handle_t handle, void *vaddr)
 {
-        struct gnttab_unmap_grant_ref op;
+        struct gnttab_unmap_grant_ref op = {
+                .host_addr = (unsigned long)vaddr,
-        gnttab_set_unmap_op(&op, (unsigned long)vaddr, GNTMAP_host_map, handle);
+                .handle    = handle,
+        };
        if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
                BUG();
@@ -728,21 +611,3 @@ enum xenbus_state xenbus_read_driver_state(const char *path)
        return result;
 }
 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
-static const struct xenbus_ring_ops ring_ops_pv = {
-        .map = xenbus_map_ring_valloc_pv,
-        .unmap = xenbus_unmap_ring_vfree_pv,
-};
-static const struct xenbus_ring_ops ring_ops_hvm = {
-        .map = xenbus_map_ring_valloc_hvm,
-        .unmap = xenbus_unmap_ring_vfree_hvm,
-};
-void __init xenbus_ring_ops_init(void)
-{
-        if (xen_pv_domain())
-                ring_ops = &ring_ops_pv;
-        else
-                ring_ops = &ring_ops_hvm;
-}
diff --git a/drivers/xen/xenbus/xenbus_comms.c b/drivers/xen/xenbus/xenbus_comms.c
index c5aa55c5d37..090c61ee8fd 100644
--- a/drivers/xen/xenbus/xenbus_comms.c
+++ b/drivers/xen/xenbus/xenbus_comms.c
@@ -212,9 +212,7 @@ int xb_init_comms(void)
                printk(KERN_WARNING "XENBUS response ring is not quiescent "
                       "(%08x:%08x): fixing up\n",
                       intf->rsp_cons, intf->rsp_prod);
-                /* breaks kdump */
+                intf->rsp_cons = intf->rsp_prod;
-                if (!reset_devices)
-                        intf->rsp_cons = intf->rsp_prod;
        }
        if (xenbus_irq) {
@@ -224,7 +222,7 @@ int xb_init_comms(void)
                int err;
                err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
                                                0, "xenbus", &xb_waitq);
-                if (err < 0) {
+                if (err <= 0) {
                        printk(KERN_ERR "XENBUS request irq failed %i\n", err);
                        return err;
                }
@@ -234,9 +232,3 @@ int xb_init_comms(void)
        return 0;
 }
-void xb_deinit_comms(void)
-{
-        unbind_from_irqhandler(xenbus_irq, &xb_waitq);
-        xenbus_irq = 0;
-}
diff --git a/drivers/xen/xenbus/xenbus_comms.h b/drivers/xen/xenbus/xenbus_comms.h
index c8abd3b8a6c..c21db751373 100644
--- a/drivers/xen/xenbus/xenbus_comms.h
+++ b/drivers/xen/xenbus/xenbus_comms.h
@@ -31,11 +31,8 @@
 #ifndef _XENBUS_COMMS_H
 #define _XENBUS_COMMS_H
-#include <linux/fs.h>
 int xs_init(void);
 int xb_init_comms(void);
-void xb_deinit_comms(void);
 /* Low level routines. */
 int xb_write(const void *data, unsigned len);
@@ -46,6 +43,4 @@ int xs_input_avail(void);
 extern struct xenstore_domain_interface *xen_store_interface;
 extern int xen_store_evtchn;
-extern const struct file_operations xen_xenbus_fops;
 #endif /* _XENBUS_COMMS_H */
diff --git a/drivers/xen/xenbus/xenbus_dev_backend.c b/drivers/xen/xenbus/xenbus_dev_backend.c
deleted file mode 100644
index d7300080076..00000000000
--- a/drivers/xen/xenbus/xenbus_dev_backend.c
+++ /dev/null
@@ -1,141 +0,0 @@
-#include <linux/slab.h>
-#include <linux/types.h>
-#include <linux/mm.h>
-#include <linux/fs.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include <linux/capability.h>
-#include <xen/xen.h>
-#include <xen/page.h>
-#include <xen/xenbus.h>
-#include <xen/xenbus_dev.h>
-#include <xen/grant_table.h>
-#include <xen/events.h>
-#include <asm/xen/hypervisor.h>
-#include "xenbus_comms.h"
-MODULE_LICENSE("GPL");
-static int xenbus_backend_open(struct inode *inode, struct file *filp)
-{
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        return nonseekable_open(inode, filp);
-}
-static long xenbus_alloc(domid_t domid)
-{
-        struct evtchn_alloc_unbound arg;
-        int err = -EEXIST;
-        xs_suspend();
-        /* If xenstored_ready is nonzero, that means we have already talked to
-         * xenstore and set up watches. These watches will be restored by
-         * xs_resume, but that requires communication over the port established
-         * below that is not visible to anyone until the ioctl returns.
-         *
-         * This can be resolved by splitting the ioctl into two parts
-         * (postponing the resume until xenstored is active) but this is
-         * unnecessarily complex for the intended use where xenstored is only
-         * started once - so return -EEXIST if it's already running.
-         */
-        if (xenstored_ready)
-                goto out_err;
-        gnttab_grant_foreign_access_ref(GNTTAB_RESERVED_XENSTORE, domid,
-                        virt_to_mfn(xen_store_interface), 0 /* writable */);
-        arg.dom = DOMID_SELF;
-        arg.remote_dom = domid;
-        err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, &arg);
-        if (err)
-                goto out_err;
-        if (xen_store_evtchn > 0)
-                xb_deinit_comms();
-        xen_store_evtchn = arg.port;
-        xs_resume();
-        return arg.port;
- out_err:
-        xs_suspend_cancel();
-        return err;
-}
-static long xenbus_backend_ioctl(struct file *file, unsigned int cmd, unsigned long data)
-{
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        switch (cmd) {
-                case IOCTL_XENBUS_BACKEND_EVTCHN:
-                        if (xen_store_evtchn > 0)
-                                return xen_store_evtchn;
-                        return -ENODEV;
-                case IOCTL_XENBUS_BACKEND_SETUP:
-                        return xenbus_alloc(data);
-                default:
-                        return -ENOTTY;
-        }
-}
-static int xenbus_backend_mmap(struct file *file, struct vm_area_struct *vma)
-{
-        size_t size = vma->vm_end - vma->vm_start;
-        if (!capable(CAP_SYS_ADMIN))
-                return -EPERM;
-        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;
-}
-static const struct file_operations xenbus_backend_fops = {
-        .open = xenbus_backend_open,
-        .mmap = xenbus_backend_mmap,
-        .unlocked_ioctl = xenbus_backend_ioctl,
-};
-static struct miscdevice xenbus_backend_dev = {
-        .minor = MISC_DYNAMIC_MINOR,
-        .name = "xen/xenbus_backend",
-        .fops = &xenbus_backend_fops,
-};
-static int __init xenbus_backend_init(void)
-{
-        int err;
-        if (!xen_initial_domain())
-                return -ENODEV;
-        err = misc_register(&xenbus_backend_dev);
-        if (err)
-                printk(KERN_ERR "Could not register xenbus backend device\n");
-        return err;
-}
-static void __exit xenbus_backend_exit(void)
-{
-        misc_deregister(&xenbus_backend_dev);
-}
-module_init(xenbus_backend_init);
-module_exit(xenbus_backend_exit);
diff --git a/drivers/xen/xenbus/xenbus_dev_frontend.c b/drivers/xen/xenbus/xenbus_dev_frontend.c
deleted file mode 100644
index ac727028e65..00000000000
--- a/drivers/xen/xenbus/xenbus_dev_frontend.c
+++ /dev/null
@@ -1,629 +0,0 @@
-/*
- * Driver giving user-space access to the kernel's xenbus connection
- * to xenstore.
- *
- * Copyright (c) 2005, Christian Limpach
- * Copyright (c) 2005, Rusty Russell, IBM Corporation
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation; or, when distributed
- * separately from the Linux kernel or incorporated into other
- * software packages, subject to the following license:
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this source file (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy, modify,
- * merge, publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- * Changes:
- * 2008-10-07  Alex Zeffertt    Replaced /proc/xen/xenbus with xenfs filesystem
- *                              and /proc/xen compatibility mount point.
- *                              Turned xenfs into a loadable module.
- */
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/uio.h>
-#include <linux/notifier.h>
-#include <linux/wait.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/mutex.h>
-#include <linux/sched.h>
-#include <linux/spinlock.h>
-#include <linux/mount.h>
-#include <linux/pagemap.h>
-#include <linux/uaccess.h>
-#include <linux/init.h>
-#include <linux/namei.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/miscdevice.h>
-#include <linux/module.h>
-#include "xenbus_comms.h"
-#include <xen/xenbus.h>
-#include <xen/xen.h>
-#include <asm/xen/hypervisor.h>
-MODULE_LICENSE("GPL");
-/*
- * An element of a list of outstanding transactions, for which we're
- * still waiting a reply.
- */
-struct xenbus_transaction_holder {
-        struct list_head list;
-        struct xenbus_transaction handle;
-};
-/*
- * A buffer of data on the queue.
- */
-struct read_buffer {
-        struct list_head list;
-        unsigned int cons;
-        unsigned int len;
-        char msg[];
-};
-struct xenbus_file_priv {
-        /*
-         * msgbuffer_mutex is held while partial requests are built up
-         * and complete requests are acted on.  It therefore protects
-         * the "transactions" and "watches" lists, and the partial
-         * request length and buffer.
-         *
-         * reply_mutex protects the reply being built up to return to
-         * usermode.  It nests inside msgbuffer_mutex but may be held
-         * alone during a watch callback.
-         */
-        struct mutex msgbuffer_mutex;
-        /* In-progress transactions */
-        struct list_head transactions;
-        /* Active watches. */
-        struct list_head watches;
-        /* Partial request. */
-        unsigned int len;
-        union {
-                struct xsd_sockmsg msg;
-                char buffer[XENSTORE_PAYLOAD_MAX];
-        } u;
-        /* Response queue. */
-        struct mutex reply_mutex;
-        struct list_head read_buffers;
-        wait_queue_head_t read_waitq;
-};
-/* Read out any raw xenbus messages queued up. */
-static ssize_t xenbus_file_read(struct file *filp,
-                               char __user *ubuf,
-                               size_t len, loff_t *ppos)
-{
-        struct xenbus_file_priv *u = filp->private_data;
-        struct read_buffer *rb;
-        unsigned i;
-        int ret;
-        mutex_lock(&u->reply_mutex);
-again:
-        while (list_empty(&u->read_buffers)) {
-                mutex_unlock(&u->reply_mutex);
-                if (filp->f_flags & O_NONBLOCK)
-                        return -EAGAIN;
-                ret = wait_event_interruptible(u->read_waitq,
-                                               !list_empty(&u->read_buffers));
-                if (ret)
-                        return ret;
-                mutex_lock(&u->reply_mutex);
-        }
-        rb = list_entry(u->read_buffers.next, struct read_buffer, list);
-        i = 0;
-        while (i < len) {
-                unsigned sz = min((unsigned)len - i, rb->len - rb->cons);
-                ret = copy_to_user(ubuf + i, &rb->msg[rb->cons], sz);
-                i += sz - ret;
-                rb->cons += sz - ret;
-                if (ret != 0) {
-                        if (i == 0)
-                                i = -EFAULT;
-                        goto out;
-                }
-                /* Clear out buffer if it has been consumed */
-                if (rb->cons == rb->len) {
-                        list_del(&rb->list);
-                        kfree(rb);
-                        if (list_empty(&u->read_buffers))
-                                break;
-                        rb = list_entry(u->read_buffers.next,
-                                        struct read_buffer, list);
-                }
-        }
-        if (i == 0)
-                goto again;
-out:
-        mutex_unlock(&u->reply_mutex);
-        return i;
-}
-/*
- * Add a buffer to the queue.  Caller must hold the appropriate lock
- * if the queue is not local.  (Commonly the caller will build up
- * multiple queued buffers on a temporary local list, and then add it
- * to the appropriate list under lock once all the buffers have een
- * successfully allocated.)
- */
-static int queue_reply(struct list_head *queue, const void *data, size_t len)
-{
-        struct read_buffer *rb;
-        if (len == 0)
-                return 0;
-        rb = kmalloc(sizeof(*rb) + len, GFP_KERNEL);
-        if (rb == NULL)
-                return -ENOMEM;
-        rb->cons = 0;
-        rb->len = len;
-        memcpy(rb->msg, data, len);
-        list_add_tail(&rb->list, queue);
-        return 0;
-}
-/*
- * Free all the read_buffer s on a list.
- * Caller must have sole reference to list.
- */
-static void queue_cleanup(struct list_head *list)
-{
-        struct read_buffer *rb;
-        while (!list_empty(list)) {
-                rb = list_entry(list->next, struct read_buffer, list);
-                list_del(list->next);
-                kfree(rb);
-        }
-}
-struct watch_adapter {
-        struct list_head list;
-        struct xenbus_watch watch;
-        struct xenbus_file_priv *dev_data;
-        char *token;
-};
-static void free_watch_adapter(struct watch_adapter *watch)
-{
-        kfree(watch->watch.node);
-        kfree(watch->token);
-        kfree(watch);
-}
-static struct watch_adapter *alloc_watch_adapter(const char *path,
-                                                 const char *token)
-{
-        struct watch_adapter *watch;
-        watch = kzalloc(sizeof(*watch), GFP_KERNEL);
-        if (watch == NULL)
-                goto out_fail;
-        watch->watch.node = kstrdup(path, GFP_KERNEL);
-        if (watch->watch.node == NULL)
-                goto out_free;
-        watch->token = kstrdup(token, GFP_KERNEL);
-        if (watch->token == NULL)
-                goto out_free;
-        return watch;
-out_free:
-        free_watch_adapter(watch);
-out_fail:
-        return NULL;
-}
-static void watch_fired(struct xenbus_watch *watch,
-                        const char **vec,
-                        unsigned int len)
-{
-        struct watch_adapter *adap;
-        struct xsd_sockmsg hdr;
-        const char *path, *token;
-        int path_len, tok_len, body_len, data_len = 0;
-        int ret;
-        LIST_HEAD(staging_q);
-        adap = container_of(watch, struct watch_adapter, watch);
-        path = vec[XS_WATCH_PATH];
-        token = adap->token;
-        path_len = strlen(path) + 1;
-        tok_len = strlen(token) + 1;
-        if (len > 2)
-                data_len = vec[len] - vec[2] + 1;
-        body_len = path_len + tok_len + data_len;
-        hdr.type = XS_WATCH_EVENT;
-        hdr.len = body_len;
-        mutex_lock(&adap->dev_data->reply_mutex);
-        ret = queue_reply(&staging_q, &hdr, sizeof(hdr));
-        if (!ret)
-                ret = queue_reply(&staging_q, path, path_len);
-        if (!ret)
-                ret = queue_reply(&staging_q, token, tok_len);
-        if (!ret && len > 2)
-                ret = queue_reply(&staging_q, vec[2], data_len);
-        if (!ret) {
-                /* success: pass reply list onto watcher */
-                list_splice_tail(&staging_q, &adap->dev_data->read_buffers);
-                wake_up(&adap->dev_data->read_waitq);
-        } else
-                queue_cleanup(&staging_q);
-        mutex_unlock(&adap->dev_data->reply_mutex);
-}
-static int xenbus_write_transaction(unsigned msg_type,
-                                    struct xenbus_file_priv *u)
-{
-        int rc;
-        void *reply;
-        struct xenbus_transaction_holder *trans = NULL;
-        LIST_HEAD(staging_q);
-        if (msg_type == XS_TRANSACTION_START) {
-                trans = kmalloc(sizeof(*trans), GFP_KERNEL);
-                if (!trans) {
-                        rc = -ENOMEM;
-                        goto out;
-                }
-        }
-        reply = xenbus_dev_request_and_reply(&u->u.msg);
-        if (IS_ERR(reply)) {
-                kfree(trans);
-                rc = PTR_ERR(reply);
-                goto out;
-        }
-        if (msg_type == XS_TRANSACTION_START) {
-                trans->handle.id = simple_strtoul(reply, NULL, 0);
-                list_add(&trans->list, &u->transactions);
-        } else if (msg_type == XS_TRANSACTION_END) {
-                list_for_each_entry(trans, &u->transactions, list)
-                        if (trans->handle.id == u->u.msg.tx_id)
-                                break;
-                BUG_ON(&trans->list == &u->transactions);
-                list_del(&trans->list);
-                kfree(trans);
-        }
-        mutex_lock(&u->reply_mutex);
-        rc = queue_reply(&staging_q, &u->u.msg, sizeof(u->u.msg));
-        if (!rc)
-                rc = queue_reply(&staging_q, reply, u->u.msg.len);
-        if (!rc) {
-                list_splice_tail(&staging_q, &u->read_buffers);
-                wake_up(&u->read_waitq);
-        } else {
-                queue_cleanup(&staging_q);
-        }
-        mutex_unlock(&u->reply_mutex);
-        kfree(reply);
-out:
-        return rc;
-}
-static int xenbus_write_watch(unsigned msg_type, struct xenbus_file_priv *u)
-{
-        struct watch_adapter *watch, *tmp_watch;
-        char *path, *token;
-        int err, rc;
-        LIST_HEAD(staging_q);
-        path = u->u.buffer + sizeof(u->u.msg);
-        token = memchr(path, 0, u->u.msg.len);
-        if (token == NULL) {
-                rc = -EILSEQ;
-                goto out;
-        }
-        token++;
-        if (memchr(token, 0, u->u.msg.len - (token - path)) == NULL) {
-                rc = -EILSEQ;
-                goto out;
-        }
-        if (msg_type == XS_WATCH) {
-                watch = alloc_watch_adapter(path, token);
-                if (watch == NULL) {
-                        rc = -ENOMEM;
-                        goto out;
-                }
-                watch->watch.callback = watch_fired;
-                watch->dev_data = u;
-                err = register_xenbus_watch(&watch->watch);
-                if (err) {
-                        free_watch_adapter(watch);
-                        rc = err;
-                        goto out;
-                }
-                list_add(&watch->list, &u->watches);
-        } else {
-                list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {
-                        if (!strcmp(watch->token, token) &&
-                            !strcmp(watch->watch.node, path)) {
-                                unregister_xenbus_watch(&watch->watch);
-                                list_del(&watch->list);
-                                free_watch_adapter(watch);
-                                break;
-                        }
-                }
-        }
-        /* Success.  Synthesize a reply to say all is OK. */
-        {
-                struct {
-                        struct xsd_sockmsg hdr;
-                        char body[3];
-                } __packed reply = {
-                        {
-                                .type = msg_type,
-                                .len = sizeof(reply.body)
-                        },
-                        "OK"
-                };
-                mutex_lock(&u->reply_mutex);
-                rc = queue_reply(&u->read_buffers, &reply, sizeof(reply));
-                wake_up(&u->read_waitq);
-                mutex_unlock(&u->reply_mutex);
-        }
-out:
-        return rc;
-}
-static ssize_t xenbus_file_write(struct file *filp,
-                                const char __user *ubuf,
-                                size_t len, loff_t *ppos)
-{
-        struct xenbus_file_priv *u = filp->private_data;
-        uint32_t msg_type;
-        int rc = len;
-        int ret;
-        LIST_HEAD(staging_q);
-        /*
-         * We're expecting usermode to be writing properly formed
-         * xenbus messages.  If they write an incomplete message we
-         * buffer it up.  Once it is complete, we act on it.
-         */
-        /*
-         * Make sure concurrent writers can't stomp all over each
-         * other's messages and make a mess of our partial message
-         * buffer.  We don't make any attemppt to stop multiple
-         * writers from making a mess of each other's incomplete
-         * messages; we're just trying to guarantee our own internal
-         * consistency and make sure that single writes are handled
-         * atomically.
-         */
-        mutex_lock(&u->msgbuffer_mutex);
-        /* Get this out of the way early to avoid confusion */
-        if (len == 0)
-                goto out;
-        /* Can't write a xenbus message larger we can buffer */
-        if (len > sizeof(u->u.buffer) - u->len) {
-                /* On error, dump existing buffer */
-                u->len = 0;
-                rc = -EINVAL;
-                goto out;
-        }
-        ret = copy_from_user(u->u.buffer + u->len, ubuf, len);
-        if (ret != 0) {
-                rc = -EFAULT;
-                goto out;
-        }
-        /* Deal with a partial copy. */
-        len -= ret;
-        rc = len;
-        u->len += len;
-        /* Return if we haven't got a full message yet */
-        if (u->len < sizeof(u->u.msg))
-                goto out;       /* not even the header yet */
-        /* If we're expecting a message that's larger than we can
-           possibly send, dump what we have and return an error. */
-        if ((sizeof(u->u.msg) + u->u.msg.len) > sizeof(u->u.buffer)) {
-                rc = -E2BIG;
-                u->len = 0;
-                goto out;
-        }
-        if (u->len < (sizeof(u->u.msg) + u->u.msg.len))
-                goto out;       /* incomplete data portion */
-        /*
-         * OK, now we have a complete message.  Do something with it.
-         */
-        msg_type = u->u.msg.type;
-        switch (msg_type) {
-        case XS_WATCH:
-        case XS_UNWATCH:
-                /* (Un)Ask for some path to be watched for changes */
-                ret = xenbus_write_watch(msg_type, u);
-                break;
-        default:
-                /* Send out a transaction */
-                ret = xenbus_write_transaction(msg_type, u);
-                break;
-        }
-        if (ret != 0)
-                rc = ret;
-        /* Buffered message consumed */
-        u->len = 0;
- out:
-        mutex_unlock(&u->msgbuffer_mutex);
-        return rc;
-}
-static int xenbus_file_open(struct inode *inode, struct file *filp)
-{
-        struct xenbus_file_priv *u;
-        if (xen_store_evtchn == 0)
-                return -ENOENT;
-        nonseekable_open(inode, filp);
-        u = kzalloc(sizeof(*u), GFP_KERNEL);
-        if (u == NULL)
-                return -ENOMEM;
-        INIT_LIST_HEAD(&u->transactions);
-        INIT_LIST_HEAD(&u->watches);
-        INIT_LIST_HEAD(&u->read_buffers);
-        init_waitqueue_head(&u->read_waitq);
-        mutex_init(&u->reply_mutex);
-        mutex_init(&u->msgbuffer_mutex);
-        filp->private_data = u;
-        return 0;
-}
-static int xenbus_file_release(struct inode *inode, struct file *filp)
-{
-        struct xenbus_file_priv *u = filp->private_data;
-        struct xenbus_transaction_holder *trans, *tmp;
-        struct watch_adapter *watch, *tmp_watch;
-        struct read_buffer *rb, *tmp_rb;
-        /*
-         * No need for locking here because there are no other users,
-         * by definition.
-         */
-        list_for_each_entry_safe(trans, tmp, &u->transactions, list) {
-                xenbus_transaction_end(trans->handle, 1);
-                list_del(&trans->list);
-                kfree(trans);
-        }
-        list_for_each_entry_safe(watch, tmp_watch, &u->watches, list) {
-                unregister_xenbus_watch(&watch->watch);
-                list_del(&watch->list);
-                free_watch_adapter(watch);
-        }
-        list_for_each_entry_safe(rb, tmp_rb, &u->read_buffers, list) {
-                list_del(&rb->list);
-                kfree(rb);
-        }
-        kfree(u);
-        return 0;
-}
-static unsigned int xenbus_file_poll(struct file *file, poll_table *wait)
-{
-        struct xenbus_file_priv *u = file->private_data;
-        poll_wait(file, &u->read_waitq, wait);
-        if (!list_empty(&u->read_buffers))
-                return POLLIN | POLLRDNORM;
-        return 0;
-}
-const struct file_operations xen_xenbus_fops = {
-        .read = xenbus_file_read,
-        .write = xenbus_file_write,
-        .open = xenbus_file_open,
-        .release = xenbus_file_release,
-        .poll = xenbus_file_poll,
-        .llseek = no_llseek,
-};
-EXPORT_SYMBOL_GPL(xen_xenbus_fops);
-static struct miscdevice xenbus_dev = {
-        .minor = MISC_DYNAMIC_MINOR,
-        .name = "xen/xenbus",
-        .fops = &xen_xenbus_fops,
-};
-static int __init xenbus_init(void)
-{
-        int err;
-        if (!xen_domain())
-                return -ENODEV;
-        err = misc_register(&xenbus_dev);
-        if (err)
-                printk(KERN_ERR "Could not register xenbus frontend device\n");
-        return err;
-}
-static void __exit xenbus_exit(void)
-{
-        misc_deregister(&xenbus_dev);
-}
-module_init(xenbus_init);
-module_exit(xenbus_exit);
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index 038b71dbf03..bd2f90c9ac8 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -46,7 +46,6 @@
 #include <linux/mutex.h>
 #include <linux/io.h>
 #include <linux/slab.h>
-#include <linux/module.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
@@ -257,12 +256,11 @@ int xenbus_dev_remove(struct device *_dev)
        DPRINTK("%s", dev->nodename);
        free_otherend_watch(dev);
+        free_otherend_details(dev);
        if (drv->remove)
                drv->remove(dev);
-        free_otherend_details(dev);
        xenbus_switch_state(dev, XenbusStateClosed);
        return 0;
 }
@@ -292,9 +290,14 @@ void xenbus_dev_shutdown(struct device *_dev)
 EXPORT_SYMBOL_GPL(xenbus_dev_shutdown);
 int xenbus_register_driver_common(struct xenbus_driver *drv,
-                                  struct xen_bus_type *bus)
+                                  struct xen_bus_type *bus,
+                                  struct module *owner,
+                                  const char *mod_name)
 {
+        drv->driver.name = drv->name;
        drv->driver.bus = &bus->bus;
+        drv->driver.owner = owner;
+        drv->driver.mod_name = mod_name;
        return driver_register(&drv->driver);
 }
@@ -306,7 +309,8 @@ void xenbus_unregister_driver(struct xenbus_driver *drv)
 }
 EXPORT_SYMBOL_GPL(xenbus_unregister_driver);
-struct xb_find_info {
+struct xb_find_info
+{
        struct xenbus_device *dev;
        const char *nodename;
 };
@@ -324,8 +328,8 @@ static int cmp_dev(struct device *dev, void *data)
        return 0;
 }
-static struct xenbus_device *xenbus_device_find(const char *nodename,
+struct xenbus_device *xenbus_device_find(const char *nodename,
-                                                struct bus_type *bus)
+                                         struct bus_type *bus)
 {
        struct xb_find_info info = { .dev = NULL, .nodename = nodename };
@@ -635,7 +639,7 @@ int xenbus_dev_cancel(struct device *dev)
 EXPORT_SYMBOL_GPL(xenbus_dev_cancel);
 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
-int xenstored_ready;
+int xenstored_ready = 0;
 int register_xenstore_notifier(struct notifier_block *nb)
@@ -680,100 +684,64 @@ static int __init xenbus_probe_initcall(void)
 device_initcall(xenbus_probe_initcall);
-/* Set up event channel for xenstored which is run as a local process
+static int __init xenbus_init(void)
- * (this is normally used only in dom0)
- */
-static int __init xenstored_local_init(void)
 {
        int err = 0;
        unsigned long page = 0;
-        struct evtchn_alloc_unbound alloc_unbound;
-        /* Allocate Xenstore page */
-        page = get_zeroed_page(GFP_KERNEL);
-        if (!page)
-                goto out_err;
-        xen_store_mfn = xen_start_info->store_mfn =
+        DPRINTK("");
-                pfn_to_mfn(virt_to_phys((void *)page) >>
-                           PAGE_SHIFT);
-        /* Next allocate a local port which xenstored can bind to */
+        err = -ENODEV;
-        alloc_unbound.dom        = DOMID_SELF;
+        if (!xen_domain())
-        alloc_unbound.remote_dom = DOMID_SELF;
+                return err;
-        err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
+        /*
-                                          &alloc_unbound);
+         * Domain0 doesn't have a store_evtchn or store_mfn yet.
-        if (err == -ENOSYS)
+         */
-                goto out_err;
+        if (xen_initial_domain()) {
+                struct evtchn_alloc_unbound alloc_unbound;
-        BUG_ON(err);
+                /* Allocate Xenstore page */
-        xen_store_evtchn = xen_start_info->store_evtchn =
+                page = get_zeroed_page(GFP_KERNEL);
-                alloc_unbound.port;
+                if (!page)
+                        goto out_error;
-        return 0;
+                xen_store_mfn = xen_start_info->store_mfn =
+                        pfn_to_mfn(virt_to_phys((void *)page) >>
+                                   PAGE_SHIFT);
- out_err:
+                /* Next allocate a local port which xenstored can bind to */
-        if (page != 0)
+                alloc_unbound.dom        = DOMID_SELF;
-                free_page(page);
+                alloc_unbound.remote_dom = 0;
-        return err;
-}
-enum xenstore_init {
+                err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
-        UNKNOWN,
+                                                  &alloc_unbound);
-        PV,
+                if (err == -ENOSYS)
-        HVM,
+                        goto out_error;
-        LOCAL,
-};
-static int __init xenbus_init(void)
-{
-        int err = 0;
-        enum xenstore_init usage = UNKNOWN;
-        uint64_t v = 0;
-        if (!xen_domain())
+                BUG_ON(err);
-                return -ENODEV;
+                xen_store_evtchn = xen_start_info->store_evtchn =
+                        alloc_unbound.port;
-        xenbus_ring_ops_init();
-        if (xen_pv_domain())
-                usage = PV;
-        if (xen_hvm_domain())
-                usage = HVM;
-        if (xen_hvm_domain() && xen_initial_domain())
-                usage = LOCAL;
-        if (xen_pv_domain() && !xen_start_info->store_evtchn)
-                usage = LOCAL;
-        if (xen_pv_domain() && xen_start_info->store_evtchn)
-                xenstored_ready = 1;
-        switch (usage) {
-        case LOCAL:
-                err = xenstored_local_init();
-                if (err)
-                        goto out_error;
                xen_store_interface = mfn_to_virt(xen_store_mfn);
-                break;
+        } else {
-        case PV:
+                if (xen_hvm_domain()) {
-                xen_store_evtchn = xen_start_info->store_evtchn;
+                        uint64_t v = 0;
-                xen_store_mfn = xen_start_info->store_mfn;
+                        err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
-                xen_store_interface = mfn_to_virt(xen_store_mfn);
+                        if (err)
-                break;
+                                goto out_error;
-        case HVM:
+                        xen_store_evtchn = (int)v;
-                err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);
+                        err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
-                if (err)
+                        if (err)
-                        goto out_error;
+                                goto out_error;
-                xen_store_evtchn = (int)v;
+                        xen_store_mfn = (unsigned long)v;
-                err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v);
+                        xen_store_interface = ioremap(xen_store_mfn << PAGE_SHIFT, PAGE_SIZE);
-                if (err)
+                } else {
-                        goto out_error;
+                        xen_store_evtchn = xen_start_info->store_evtchn;
-                xen_store_mfn = (unsigned long)v;
+                        xen_store_mfn = xen_start_info->store_mfn;
-                xen_store_interface =
+                        xen_store_interface = mfn_to_virt(xen_store_mfn);
-                        ioremap(xen_store_mfn << PAGE_SHIFT, PAGE_SIZE);
+                        xenstored_ready = 1;
-                break;
+                }
-        default:
-                pr_warn("Xenstore state unknown\n");
-                break;
        }
        /* Initialize the interface to xenstore. */
@@ -792,7 +760,12 @@ static int __init xenbus_init(void)
        proc_mkdir("xen", NULL);
 #endif
-out_error:
+        return 0;
+  out_error:
+        if (page != 0)
+                free_page(page);
        return err;
 }
diff --git a/drivers/xen/xenbus/xenbus_probe.h b/drivers/xen/xenbus/xenbus_probe.h
index bb4f92ed873..b814935378c 100644
--- a/drivers/xen/xenbus/xenbus_probe.h
+++ b/drivers/xen/xenbus/xenbus_probe.h
@@ -36,7 +36,8 @@
 #define XEN_BUS_ID_SIZE                 20
-struct xen_bus_type {
+struct xen_bus_type
+{
        char *root;
        unsigned int levels;
        int (*get_bus_id)(char bus_id[XEN_BUS_ID_SIZE], const char *nodename);
@@ -53,7 +54,9 @@ extern int xenbus_match(struct device *_dev, struct device_driver *_drv);
 extern int xenbus_dev_probe(struct device *_dev);
 extern int xenbus_dev_remove(struct device *_dev);
 extern int xenbus_register_driver_common(struct xenbus_driver *drv,
-                                         struct xen_bus_type *bus);
+                                         struct xen_bus_type *bus,
+                                         struct module *owner,
+                                         const char *mod_name);
 extern int xenbus_probe_node(struct xen_bus_type *bus,
                             const char *type,
                             const char *nodename);
@@ -74,6 +77,4 @@ extern void xenbus_otherend_changed(struct xenbus_watch *watch,
 extern int xenbus_read_otherend_details(struct xenbus_device *xendev,
                                        char *id_node, char *path_node);
-void xenbus_ring_ops_init(void);
 #endif
diff --git a/drivers/xen/xenbus/xenbus_probe_backend.c b/drivers/xen/xenbus/xenbus_probe_backend.c
index 257be37d909..60adf919d78 100644
--- a/drivers/xen/xenbus/xenbus_probe_backend.c
+++ b/drivers/xen/xenbus/xenbus_probe_backend.c
@@ -42,7 +42,6 @@
 #include <linux/fcntl.h>
 #include <linux/mm.h>
 #include <linux/notifier.h>
-#include <linux/export.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
@@ -105,6 +104,8 @@ static int xenbus_uevent_backend(struct device *dev,
        xdev = to_xenbus_device(dev);
        bus = container_of(xdev->dev.bus, struct xen_bus_type, bus);
+        if (xdev == NULL)
+                return -ENODEV;
        if (add_uevent_var(env, "MODALIAS=xen-backend:%s", xdev->devicetype))
                return -ENOMEM;
@@ -232,13 +233,15 @@ int xenbus_dev_is_online(struct xenbus_device *dev)
 }
 EXPORT_SYMBOL_GPL(xenbus_dev_is_online);
-int xenbus_register_backend(struct xenbus_driver *drv)
+int __xenbus_register_backend(struct xenbus_driver *drv,
+                              struct module *owner, const char *mod_name)
 {
        drv->read_otherend_details = read_frontend_details;
-        return xenbus_register_driver_common(drv, &xenbus_backend);
+        return xenbus_register_driver_common(drv, &xenbus_backend,
+                                             owner, mod_name);
 }
-EXPORT_SYMBOL_GPL(xenbus_register_backend);
+EXPORT_SYMBOL_GPL(__xenbus_register_backend);
 static int backend_probe_and_watch(struct notifier_block *notifier,
                                   unsigned long event,
diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
index 3159a37d966..ed2ba474a56 100644
--- a/drivers/xen/xenbus/xenbus_probe_frontend.c
+++ b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -13,7 +13,6 @@
 #include <linux/kthread.h>
 #include <linux/mutex.h>
 #include <linux/io.h>
-#include <linux/module.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
@@ -21,7 +20,6 @@
 #include <xen/xenbus.h>
 #include <xen/events.h>
 #include <xen/page.h>
-#include <xen/xen.h>
 #include <xen/platform_pci.h>
@@ -54,12 +52,6 @@ static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
        char *nodename;
        int err;
-        /* ignore console/0 */
-        if (!strncmp(type, "console", 7) && !strncmp(name, "0", 1)) {
-                DPRINTK("Ignoring buggy device entry console/0");
-                return 0;
-        }
        nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
        if (!nodename)
                return -ENOMEM;
@@ -136,7 +128,7 @@ static int read_backend_details(struct xenbus_device *xendev)
        return xenbus_read_otherend_details(xendev, "backend-id", "backend");
 }
-static int is_device_connecting(struct device *dev, void *data, bool ignore_nonessential)
+static int is_device_connecting(struct device *dev, void *data)
 {
        struct xenbus_device *xendev = to_xenbus_device(dev);
        struct device_driver *drv = data;
@@ -153,41 +145,16 @@ static int is_device_connecting(struct device *dev, void *data, bool ignore_none
        if (drv && (dev->driver != drv))
                return 0;
-        if (ignore_nonessential) {
-                /* With older QEMU, for PVonHVM guests the guest config files
-                 * could contain: vfb = [ 'vnc=1, vnclisten=0.0.0.0']
-                 * which is nonsensical as there is no PV FB (there can be
-                 * a PVKB) running as HVM guest. */
-                if ((strncmp(xendev->nodename, "device/vkbd", 11) == 0))
-                        return 0;
-                if ((strncmp(xendev->nodename, "device/vfb", 10) == 0))
-                        return 0;
-        }
        xendrv = to_xenbus_driver(dev->driver);
        return (xendev->state < XenbusStateConnected ||
                (xendev->state == XenbusStateConnected &&
                 xendrv->is_ready && !xendrv->is_ready(xendev)));
 }
-static int essential_device_connecting(struct device *dev, void *data)
-{
-        return is_device_connecting(dev, data, true /* ignore PV[KBB+FB] */);
-}
-static int non_essential_device_connecting(struct device *dev, void *data)
-{
-        return is_device_connecting(dev, data, false);
-}
-static int exists_essential_connecting_device(struct device_driver *drv)
+static int exists_connecting_device(struct device_driver *drv)
 {
        return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                essential_device_connecting);
+                                is_device_connecting);
-}
-static int exists_non_essential_connecting_device(struct device_driver *drv)
-{
-        return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                non_essential_device_connecting);
 }
 static int print_device_status(struct device *dev, void *data)
@@ -218,23 +185,6 @@ static int print_device_status(struct device *dev, void *data)
 /* We only wait for device setup after most initcalls have run. */
 static int ready_to_wait_for_devices;
-static bool wait_loop(unsigned long start, unsigned int max_delay,
-                     unsigned int *seconds_waited)
-{
-        if (time_after(jiffies, start + (*seconds_waited+5)*HZ)) {
-                if (!*seconds_waited)
-                        printk(KERN_WARNING "XENBUS: Waiting for "
-                               "devices to initialise: ");
-                *seconds_waited += 5;
-                printk("%us...", max_delay - *seconds_waited);
-                if (*seconds_waited == max_delay)
-                        return true;
-        }
-        schedule_timeout_interruptible(HZ/10);
-        return false;
-}
 /*
 * On a 5-minute timeout, wait for all devices currently configured.  We need
 * to do this to guarantee that the filesystems and / or network devices
@@ -258,14 +208,19 @@ static void wait_for_devices(struct xenbus_driver *xendrv)
        if (!ready_to_wait_for_devices || !xen_domain())
                return;
-        while (exists_non_essential_connecting_device(drv))
+        while (exists_connecting_device(drv)) {
-                if (wait_loop(start, 30, &seconds_waited))
+                if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
-                        break;
+                        if (!seconds_waited)
+                                printk(KERN_WARNING "XENBUS: Waiting for "
-        /* Skips PVKB and PVFB check.*/
+                                       "devices to initialise: ");
-        while (exists_essential_connecting_device(drv))
+                        seconds_waited += 5;
-                if (wait_loop(start, 270, &seconds_waited))
+                        printk("%us...", 300 - seconds_waited);
-                        break;
+                        if (seconds_waited == 300)
+                                break;
+                }
+                schedule_timeout_interruptible(HZ/10);
+        }
        if (seconds_waited)
                printk("\n");
@@ -274,13 +229,15 @@ static void wait_for_devices(struct xenbus_driver *xendrv)
                         print_device_status);
 }
-int xenbus_register_frontend(struct xenbus_driver *drv)
+int __xenbus_register_frontend(struct xenbus_driver *drv,
+                               struct module *owner, const char *mod_name)
 {
        int ret;
        drv->read_otherend_details = read_backend_details;
-        ret = xenbus_register_driver_common(drv, &xenbus_frontend);
+        ret = xenbus_register_driver_common(drv, &xenbus_frontend,
+                                            owner, mod_name);
        if (ret)
                return ret;
@@ -289,133 +246,12 @@ int xenbus_register_frontend(struct xenbus_driver *drv)
        return 0;
 }
-EXPORT_SYMBOL_GPL(xenbus_register_frontend);
+EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
-static DECLARE_WAIT_QUEUE_HEAD(backend_state_wq);
-static int backend_state;
-static void xenbus_reset_backend_state_changed(struct xenbus_watch *w,
-                                        const char **v, unsigned int l)
-{
-        xenbus_scanf(XBT_NIL, v[XS_WATCH_PATH], "", "%i", &backend_state);
-        printk(KERN_DEBUG "XENBUS: backend %s %s\n",
-                        v[XS_WATCH_PATH], xenbus_strstate(backend_state));
-        wake_up(&backend_state_wq);
-}
-static void xenbus_reset_wait_for_backend(char *be, int expected)
-{
-        long timeout;
-        timeout = wait_event_interruptible_timeout(backend_state_wq,
-                        backend_state == expected, 5 * HZ);
-        if (timeout <= 0)
-                printk(KERN_INFO "XENBUS: backend %s timed out.\n", be);
-}
-/*
- * Reset frontend if it is in Connected or Closed state.
- * Wait for backend to catch up.
- * State Connected happens during kdump, Closed after kexec.
- */
-static void xenbus_reset_frontend(char *fe, char *be, int be_state)
-{
-        struct xenbus_watch be_watch;
-        printk(KERN_DEBUG "XENBUS: backend %s %s\n",
-                        be, xenbus_strstate(be_state));
-        memset(&be_watch, 0, sizeof(be_watch));
-        be_watch.node = kasprintf(GFP_NOIO | __GFP_HIGH, "%s/state", be);
-        if (!be_watch.node)
-                return;
-        be_watch.callback = xenbus_reset_backend_state_changed;
-        backend_state = XenbusStateUnknown;
-        printk(KERN_INFO "XENBUS: triggering reconnect on %s\n", be);
-        register_xenbus_watch(&be_watch);
-        /* fall through to forward backend to state XenbusStateInitialising */
-        switch (be_state) {
-        case XenbusStateConnected:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosing);
-                xenbus_reset_wait_for_backend(be, XenbusStateClosing);
-        case XenbusStateClosing:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateClosed);
-                xenbus_reset_wait_for_backend(be, XenbusStateClosed);
-        case XenbusStateClosed:
-                xenbus_printf(XBT_NIL, fe, "state", "%d", XenbusStateInitialising);
-                xenbus_reset_wait_for_backend(be, XenbusStateInitWait);
-        }
-        unregister_xenbus_watch(&be_watch);
-        printk(KERN_INFO "XENBUS: reconnect done on %s\n", be);
-        kfree(be_watch.node);
-}
-static void xenbus_check_frontend(char *class, char *dev)
-{
-        int be_state, fe_state, err;
-        char *backend, *frontend;
-        frontend = kasprintf(GFP_NOIO | __GFP_HIGH, "device/%s/%s", class, dev);
-        if (!frontend)
-                return;
-        err = xenbus_scanf(XBT_NIL, frontend, "state", "%i", &fe_state);
-        if (err != 1)
-                goto out;
-        switch (fe_state) {
-        case XenbusStateConnected:
-        case XenbusStateClosed:
-                printk(KERN_DEBUG "XENBUS: frontend %s %s\n",
-                                frontend, xenbus_strstate(fe_state));
-                backend = xenbus_read(XBT_NIL, frontend, "backend", NULL);
-                if (!backend || IS_ERR(backend))
-                        goto out;
-                err = xenbus_scanf(XBT_NIL, backend, "state", "%i", &be_state);
-                if (err == 1)
-                        xenbus_reset_frontend(frontend, backend, be_state);
-                kfree(backend);
-                break;
-        default:
-                break;
-        }
-out:
-        kfree(frontend);
-}
-static void xenbus_reset_state(void)
-{
-        char **devclass, **dev;
-        int devclass_n, dev_n;
-        int i, j;
-        devclass = xenbus_directory(XBT_NIL, "device", "", &devclass_n);
-        if (IS_ERR(devclass))
-                return;
-        for (i = 0; i < devclass_n; i++) {
-                dev = xenbus_directory(XBT_NIL, "device", devclass[i], &dev_n);
-                if (IS_ERR(dev))
-                        continue;
-                for (j = 0; j < dev_n; j++)
-                        xenbus_check_frontend(devclass[i], dev[j]);
-                kfree(dev);
-        }
-        kfree(devclass);
-}
 static int frontend_probe_and_watch(struct notifier_block *notifier,
                                   unsigned long event,
                                   void *data)
 {
-        /* reset devices in Connected or Closed state */
-        if (xen_hvm_domain())
-                xenbus_reset_state();
        /* Enumerate devices in xenstore and watch for changes. */
        xenbus_probe_devices(&xenbus_frontend);
        register_xenbus_watch(&fe_watch);
diff --git a/drivers/xen/xenbus/xenbus_xs.c b/drivers/xen/xenbus/xenbus_xs.c
index 88e677b0de7..daee5db4bef 100644
--- a/drivers/xen/xenbus/xenbus_xs.c
+++ b/drivers/xen/xenbus/xenbus_xs.c
@@ -44,9 +44,7 @@
 #include <linux/rwsem.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
-#include <asm/xen/hypervisor.h>
 #include <xen/xenbus.h>
-#include <xen/xen.h>
 #include "xenbus_comms.h"
 struct xs_stored_msg {
@@ -533,18 +531,21 @@ int xenbus_printf(struct xenbus_transaction t,
 {
        va_list ap;
        int ret;
-        char *buf;
+#define PRINTF_BUFFER_SIZE 4096
+        char *printf_buffer;
+        printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_NOIO | __GFP_HIGH);
+        if (printf_buffer == NULL)
+                return -ENOMEM;
        va_start(ap, fmt);
-        buf = kvasprintf(GFP_NOIO | __GFP_HIGH, fmt, ap);
+        ret = vsnprintf(printf_buffer, PRINTF_BUFFER_SIZE, fmt, ap);
        va_end(ap);
-        if (!buf)
+        BUG_ON(ret > PRINTF_BUFFER_SIZE-1);
-                return -ENOMEM;
+        ret = xenbus_write(t, dir, node, printf_buffer);
-        ret = xenbus_write(t, dir, node, buf);
+        kfree(printf_buffer);
-        kfree(buf);
        return ret;
 }
@@ -618,45 +619,6 @@ static struct xenbus_watch *find_watch(const char *token)
        return NULL;
 }
-/*
- * Certain older XenBus toolstack cannot handle reading values that are
- * not populated. Some Xen 3.4 installation are incapable of doing this
- * so if we are running on anything older than 4 do not attempt to read
- * control/platform-feature-xs_reset_watches.
- */
-static bool xen_strict_xenbus_quirk(void)
-{
-#ifdef CONFIG_X86
-        uint32_t eax, ebx, ecx, edx, base;
-        base = xen_cpuid_base();
-        cpuid(base + 1, &eax, &ebx, &ecx, &edx);
-        if ((eax >> 16) < 4)
-                return true;
-#endif
-        return false;
-}
-static void xs_reset_watches(void)
-{
-        int err, supported = 0;
-        if (!xen_hvm_domain() || xen_initial_domain())
-                return;
-        if (xen_strict_xenbus_quirk())
-                return;
-        err = xenbus_scanf(XBT_NIL, "control",
-                        "platform-feature-xs_reset_watches", "%d", &supported);
-        if (err != 1 || !supported)
-                return;
-        err = xs_error(xs_single(XBT_NIL, XS_RESET_WATCHES, "", NULL));
-        if (err && err != -EEXIST)
-                printk(KERN_WARNING "xs_reset_watches failed: %d\n", err);
-}
 /* Register callback to watch this node. */
 int register_xenbus_watch(struct xenbus_watch *watch)
@@ -676,7 +638,8 @@ int register_xenbus_watch(struct xenbus_watch *watch)
        err = xs_watch(watch->node, token);
-        if (err) {
+        /* Ignore errors due to multiple registration. */
+        if ((err != 0) && (err != -EEXIST)) {
                spin_lock(&watches_lock);
                list_del(&watch->list);
                spin_unlock(&watches_lock);
@@ -940,8 +903,5 @@ int xs_init(void)
        if (IS_ERR(task))
                return PTR_ERR(task);
-        /* shutdown watches for kexec boot */
-        xs_reset_watches();
        return 0;
 }
diff --git a/drivers/xen/xenfs/Makefile b/drivers/xen/xenfs/Makefile
index b019865fcc5..4fde9440fe1 100644
--- a/drivers/xen/xenfs/Makefile
+++ b/drivers/xen/xenfs/Makefile
@@ -1,4 +1,4 @@
 obj-$(CONFIG_XENFS) += xenfs.o
-xenfs-y                   = super.o
+xenfs-y                   = super.o xenbus.o privcmd.o
 xenfs-$(CONFIG_XEN_DOM0) += xenstored.o
diff --git a/drivers/xen/xenfs/super.c b/drivers/xen/xenfs/super.c
index 459b9ac45cf..1aa38971984 100644
--- a/drivers/xen/xenfs/super.c
+++ b/drivers/xen/xenfs/super.c
@@ -16,8 +16,6 @@
 #include <xen/xen.h>
 #include "xenfs.h"
-#include "../privcmd.h"
-#include "../xenbus/xenbus_comms.h"
 #include <asm/xen/hypervisor.h>
@@ -30,8 +28,7 @@ static struct inode *xenfs_make_inode(struct super_block *sb, int mode)
        if (ret) {
                ret->i_mode = mode;
-                ret->i_uid = GLOBAL_ROOT_UID;
+                ret->i_uid = ret->i_gid = 0;
-                ret->i_gid = GLOBAL_ROOT_GID;
                ret->i_blocks = 0;
                ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
        }
@@ -85,9 +82,9 @@ static int xenfs_fill_super(struct super_block *sb, void *data, int silent)
 {
        static struct tree_descr xenfs_files[] = {
                [1] = {},
-                { "xenbus", &xen_xenbus_fops, S_IRUSR|S_IWUSR },
+                { "xenbus", &xenbus_file_ops, S_IRUSR|S_IWUSR },
                { "capabilities", &capabilities_file_ops, S_IRUGO },
-                { "privcmd", &xen_privcmd_fops, S_IRUSR|S_IWUSR },
+                { "privcmd", &privcmd_file_ops, S_IRUSR|S_IWUSR },
                {""},
        };
        int rc;
diff --git a/drivers/xen/xenfs/xenfs.h b/drivers/xen/xenfs/xenfs.h
index 6b80c7779c0..b68aa620000 100644
--- a/drivers/xen/xenfs/xenfs.h
+++ b/drivers/xen/xenfs/xenfs.h
@@ -1,6 +1,8 @@
 #ifndef _XENFS_XENBUS_H
 #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;