Merge branch 'linus' into x86/asm, before applying dependent patch

Signed-off-by: Ingo Molnar <mingo@kernel.org>

7 files changed, 338 insertions, 349 deletions

diff --git a/arch/x86/xen/apic.c b/arch/x86/xen/apic.c
index 7005ced5d1ad..70e060ad879a 100644
--- a/arch/x86/xen/apic.c
+++ b/arch/x86/xen/apic.c
@@ -7,6 +7,7 @@
 #include <xen/xen.h>
 #include <xen/interface/physdev.h>
 #include "xen-ops.h"
+#include "smp.h"
 
 static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
 {
@@ -28,7 +29,186 @@ static unsigned int xen_io_apic_read(unsigned apic, unsigned reg)
         return 0xfd;
 }
 
+static unsigned long xen_set_apic_id(unsigned int x)
+{
+        WARN_ON(1);
+        return x;
+}
+
+static unsigned int xen_get_apic_id(unsigned long x)
+{
+        return ((x)>>24) & 0xFFu;
+}
+
+static u32 xen_apic_read(u32 reg)
+{
+        struct xen_platform_op op = {
+                .cmd = XENPF_get_cpuinfo,
+                .interface_version = XENPF_INTERFACE_VERSION,
+                .u.pcpu_info.xen_cpuid = 0,
+        };
+        int ret = 0;
+
+        /* Shouldn't need this as APIC is turned off for PV, and we only
+         * get called on the bootup processor. But just in case. */
+        if (!xen_initial_domain() || smp_processor_id())
+                return 0;
+
+        if (reg == APIC_LVR)
+                return 0x10;
+#ifdef CONFIG_X86_32
+        if (reg == APIC_LDR)
+                return SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
+#endif
+        if (reg != APIC_ID)
+                return 0;
+
+        ret = HYPERVISOR_dom0_op(&op);
+        if (ret)
+                return 0;
+
+        return op.u.pcpu_info.apic_id << 24;
+}
+
+static void xen_apic_write(u32 reg, u32 val)
+{
+        /* Warn to see if there's any stray references */
+        WARN(1,"register: %x, value: %x\n", reg, val);
+}
+
+static u64 xen_apic_icr_read(void)
+{
+        return 0;
+}
+
+static void xen_apic_icr_write(u32 low, u32 id)
+{
+        /* Warn to see if there's any stray references */
+        WARN_ON(1);
+}
+
+static u32 xen_safe_apic_wait_icr_idle(void)
+{
+        return 0;
+}
+
+static int xen_apic_probe_pv(void)
+{
+        if (xen_pv_domain())
+                return 1;
+
+        return 0;
+}
+
+static int xen_madt_oem_check(char *oem_id, char *oem_table_id)
+{
+        return xen_pv_domain();
+}
+
+static int xen_id_always_valid(int apicid)
+{
+        return 1;
+}
+
+static int xen_id_always_registered(void)
+{
+        return 1;
+}
+
+static int xen_phys_pkg_id(int initial_apic_id, int index_msb)
+{
+        return initial_apic_id >> index_msb;
+}
+
+#ifdef CONFIG_X86_32
+static int xen_x86_32_early_logical_apicid(int cpu)
+{
+        /* Match with APIC_LDR read. Otherwise setup_local_APIC complains. */
+        return 1 << cpu;
+}
+#endif
+
+static void xen_noop(void)
+{
+}
+
+static void xen_silent_inquire(int apicid)
+{
+}
+
+static struct apic xen_pv_apic = {
+        .name                           = "Xen PV",
+        .probe                          = xen_apic_probe_pv,
+        .acpi_madt_oem_check            = xen_madt_oem_check,
+        .apic_id_valid                  = xen_id_always_valid,
+        .apic_id_registered             = xen_id_always_registered,
+
+        /* .irq_delivery_mode - used in native_compose_msi_msg only */
+        /* .irq_dest_mode     - used in native_compose_msi_msg only */
+
+        .target_cpus                    = default_target_cpus,
+        .disable_esr                    = 0,
+        /* .dest_logical      -  default_send_IPI_ use it but we use our own. */
+        .check_apicid_used              = default_check_apicid_used, /* Used on 32-bit */
+
+        .vector_allocation_domain       = flat_vector_allocation_domain,
+        .init_apic_ldr                  = xen_noop, /* setup_local_APIC calls it */
+
+        .ioapic_phys_id_map             = default_ioapic_phys_id_map, /* Used on 32-bit */
+        .setup_apic_routing             = NULL,
+        .cpu_present_to_apicid          = default_cpu_present_to_apicid,
+        .apicid_to_cpu_present          = physid_set_mask_of_physid, /* Used on 32-bit */
+        .check_phys_apicid_present      = default_check_phys_apicid_present, /* smp_sanity_check needs it */
+        .phys_pkg_id                    = xen_phys_pkg_id, /* detect_ht */
+
+        .get_apic_id                    = xen_get_apic_id,
+        .set_apic_id                    = xen_set_apic_id, /* Can be NULL on 32-bit. */
+        .apic_id_mask                   = 0xFF << 24, /* Used by verify_local_APIC. Match with what xen_get_apic_id does. */
+
+        .cpu_mask_to_apicid_and         = flat_cpu_mask_to_apicid_and,
+
+#ifdef CONFIG_SMP
+        .send_IPI_mask                  = xen_send_IPI_mask,
+        .send_IPI_mask_allbutself       = xen_send_IPI_mask_allbutself,
+        .send_IPI_allbutself            = xen_send_IPI_allbutself,
+        .send_IPI_all                   = xen_send_IPI_all,
+        .send_IPI_self                  = xen_send_IPI_self,
+#endif
+        /* .wait_for_init_deassert- used  by AP bootup - smp_callin which we don't use */
+        .inquire_remote_apic            = xen_silent_inquire,
+
+        .read                           = xen_apic_read,
+        .write                          = xen_apic_write,
+        .eoi_write                      = xen_apic_write,
+
+        .icr_read                       = xen_apic_icr_read,
+        .icr_write                      = xen_apic_icr_write,
+        .wait_icr_idle                  = xen_noop,
+        .safe_wait_icr_idle             = xen_safe_apic_wait_icr_idle,
+
+#ifdef CONFIG_X86_32
+        /* generic_processor_info and setup_local_APIC. */
+        .x86_32_early_logical_apicid    = xen_x86_32_early_logical_apicid,
+#endif
+};
+
+static void __init xen_apic_check(void)
+{
+        if (apic == &xen_pv_apic)
+                return;
+
+        pr_info("Switched APIC routing from %s to %s.\n", apic->name,
+                xen_pv_apic.name);
+        apic = &xen_pv_apic;
+}
 void __init xen_init_apic(void)
 {
         x86_io_apic_ops.read = xen_io_apic_read;
+        /* On PV guests the APIC CPUID bit is disabled so none of the
+         * routines end up executing. */
+        if (!xen_initial_domain())
+                apic = &xen_pv_apic;
+
+        x86_platform.apic_post_init = xen_apic_check;
 }
+apic_driver(xen_pv_apic);
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index 3797b6b31f95..fe969ac1c65e 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -928,92 +928,6 @@ static void xen_io_delay(void)
 {
 }
 
-#ifdef CONFIG_X86_LOCAL_APIC
-static unsigned long xen_set_apic_id(unsigned int x)
-{
-        WARN_ON(1);
-        return x;
-}
-static unsigned int xen_get_apic_id(unsigned long x)
-{
-        return ((x)>>24) & 0xFFu;
-}
-static u32 xen_apic_read(u32 reg)
-{
-        struct xen_platform_op op = {
-                .cmd = XENPF_get_cpuinfo,
-                .interface_version = XENPF_INTERFACE_VERSION,
-                .u.pcpu_info.xen_cpuid = 0,
-        };
-        int ret = 0;
-
-        /* Shouldn't need this as APIC is turned off for PV, and we only
-         * get called on the bootup processor. But just in case. */
-        if (!xen_initial_domain() || smp_processor_id())
-                return 0;
-
-        if (reg == APIC_LVR)
-                return 0x10;
-
-        if (reg != APIC_ID)
-                return 0;
-
-        ret = HYPERVISOR_dom0_op(&op);
-        if (ret)
-                return 0;
-
-        return op.u.pcpu_info.apic_id << 24;
-}
-
-static void xen_apic_write(u32 reg, u32 val)
-{
-        /* Warn to see if there's any stray references */
-        WARN_ON(1);
-}
-
-static u64 xen_apic_icr_read(void)
-{
-        return 0;
-}
-
-static void xen_apic_icr_write(u32 low, u32 id)
-{
-        /* Warn to see if there's any stray references */
-        WARN_ON(1);
-}
-
-static void xen_apic_wait_icr_idle(void)
-{
-        return;
-}
-
-static u32 xen_safe_apic_wait_icr_idle(void)
-{
-        return 0;
-}
-
-static void set_xen_basic_apic_ops(void)
-{
-        apic->read = xen_apic_read;
-        apic->write = xen_apic_write;
-        apic->icr_read = xen_apic_icr_read;
-        apic->icr_write = xen_apic_icr_write;
-        apic->wait_icr_idle = xen_apic_wait_icr_idle;
-        apic->safe_wait_icr_idle = xen_safe_apic_wait_icr_idle;
-        apic->set_apic_id = xen_set_apic_id;
-        apic->get_apic_id = xen_get_apic_id;
-
-#ifdef CONFIG_SMP
-        apic->send_IPI_allbutself = xen_send_IPI_allbutself;
-        apic->send_IPI_mask_allbutself = xen_send_IPI_mask_allbutself;
-        apic->send_IPI_mask = xen_send_IPI_mask;
-        apic->send_IPI_all = xen_send_IPI_all;
-        apic->send_IPI_self = xen_send_IPI_self;
-#endif
-}
-
-#endif
-
 static void xen_clts(void)
 {
         struct multicall_space mcs;
@@ -1620,7 +1534,7 @@ asmlinkage __visible void __init xen_start_kernel(void)
         /*
          * set up the basic apic ops.
          */
-        set_xen_basic_apic_ops();
+        xen_init_apic();
 #endif
 
         if (xen_feature(XENFEAT_mmu_pt_update_preserve_ad)) {
@@ -1733,8 +1647,6 @@ asmlinkage __visible void __init xen_start_kernel(void)
                 if (HYPERVISOR_dom0_op(&op) == 0)
                         boot_params.kbd_status = op.u.firmware_info.u.kbd_shift_flags;
 
-                xen_init_apic();
-
                 /* Make sure ACS will be enabled */
                 pci_request_acs();
 
@@ -1849,6 +1761,9 @@ static struct notifier_block xen_hvm_cpu_notifier = {
 
 static void __init xen_hvm_guest_init(void)
 {
+        if (xen_pv_domain())
+                return;
+
         init_hvm_pv_info();
 
         xen_hvm_init_shared_info();
@@ -1864,6 +1779,7 @@ static void __init xen_hvm_guest_init(void)
         xen_hvm_init_time_ops();
         xen_hvm_init_mmu_ops();
 }
+#endif
 
 static bool xen_nopv = false;
 static __init int xen_parse_nopv(char *arg)
@@ -1873,14 +1789,11 @@ static __init int xen_parse_nopv(char *arg)
 }
 early_param("xen_nopv", xen_parse_nopv);
 
-static uint32_t __init xen_hvm_platform(void)
+static uint32_t __init xen_platform(void)
 {
         if (xen_nopv)
                 return 0;
 
-        if (xen_pv_domain())
-                return 0;
-
         return xen_cpuid_base();
 }
 
@@ -1898,11 +1811,19 @@ bool xen_hvm_need_lapic(void)
 }
 EXPORT_SYMBOL_GPL(xen_hvm_need_lapic);
 
-const struct hypervisor_x86 x86_hyper_xen_hvm __refconst = {
-        .name                   = "Xen HVM",
-        .detect                 = xen_hvm_platform,
+static void xen_set_cpu_features(struct cpuinfo_x86 *c)
+{
+        if (xen_pv_domain())
+                clear_cpu_bug(c, X86_BUG_SYSRET_SS_ATTRS);
+}
+
+const struct hypervisor_x86 x86_hyper_xen = {
+        .name                   = "Xen",
+        .detect                 = xen_platform,
+#ifdef CONFIG_XEN_PVHVM
         .init_platform          = xen_hvm_guest_init,
+#endif
         .x2apic_available       = xen_x2apic_para_available,
+        .set_cpu_features       = xen_set_cpu_features,
 };
-EXPORT_SYMBOL(x86_hyper_xen_hvm);
-#endif
+EXPORT_SYMBOL(x86_hyper_xen);
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index adca9e2b6553..dd151b2045b0 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -502,7 +502,7 @@ __visible pmd_t xen_make_pmd(pmdval_t pmd)
 }
 PV_CALLEE_SAVE_REGS_THUNK(xen_make_pmd);
 
-#if PAGETABLE_LEVELS == 4
+#if CONFIG_PGTABLE_LEVELS == 4
 __visible pudval_t xen_pud_val(pud_t pud)
 {
         return pte_mfn_to_pfn(pud.pud);
@@ -589,7 +589,7 @@ static void xen_set_pgd(pgd_t *ptr, pgd_t val)
 
         xen_mc_issue(PARAVIRT_LAZY_MMU);
 }
-#endif  /* PAGETABLE_LEVELS == 4 */
+#endif  /* CONFIG_PGTABLE_LEVELS == 4 */
 
 /*
  * (Yet another) pagetable walker.  This one is intended for pinning a
@@ -1628,7 +1628,7 @@ static void xen_release_pmd(unsigned long pfn)
         xen_release_ptpage(pfn, PT_PMD);
 }
 
-#if PAGETABLE_LEVELS == 4
+#if CONFIG_PGTABLE_LEVELS == 4
 static void xen_alloc_pud(struct mm_struct *mm, unsigned long pfn)
 {
         xen_alloc_ptpage(mm, pfn, PT_PUD);
@@ -2046,7 +2046,7 @@ static void __init xen_post_allocator_init(void)
         pv_mmu_ops.set_pte = xen_set_pte;
         pv_mmu_ops.set_pmd = xen_set_pmd;
         pv_mmu_ops.set_pud = xen_set_pud;
-#if PAGETABLE_LEVELS == 4
+#if CONFIG_PGTABLE_LEVELS == 4
         pv_mmu_ops.set_pgd = xen_set_pgd;
 #endif
 
@@ -2056,7 +2056,7 @@ static void __init xen_post_allocator_init(void)
         pv_mmu_ops.alloc_pmd = xen_alloc_pmd;
         pv_mmu_ops.release_pte = xen_release_pte;
         pv_mmu_ops.release_pmd = xen_release_pmd;
-#if PAGETABLE_LEVELS == 4
+#if CONFIG_PGTABLE_LEVELS == 4
         pv_mmu_ops.alloc_pud = xen_alloc_pud;
         pv_mmu_ops.release_pud = xen_release_pud;
 #endif
@@ -2122,14 +2122,14 @@ static const struct pv_mmu_ops xen_mmu_ops __initconst = {
         .make_pmd = PV_CALLEE_SAVE(xen_make_pmd),
         .pmd_val = PV_CALLEE_SAVE(xen_pmd_val),
 
-#if PAGETABLE_LEVELS == 4
+#if CONFIG_PGTABLE_LEVELS == 4
         .pud_val = PV_CALLEE_SAVE(xen_pud_val),
         .make_pud = PV_CALLEE_SAVE(xen_make_pud),
         .set_pgd = xen_set_pgd_hyper,
 
         .alloc_pud = xen_alloc_pmd_init,
         .release_pud = xen_release_pmd_init,
-#endif  /* PAGETABLE_LEVELS == 4 */
+#endif  /* CONFIG_PGTABLE_LEVELS == 4 */
 
         .activate_mm = xen_activate_mm,
         .dup_mmap = xen_dup_mmap,
@@ -2436,99 +2436,11 @@ void __init xen_hvm_init_mmu_ops(void)
 }
 #endif
 
-#ifdef CONFIG_XEN_PVH
-/*
- * Map foreign gfn (fgfn), to local pfn (lpfn). This for the user
- * space creating new guest on pvh dom0 and needing to map domU pages.
- */
-static int xlate_add_to_p2m(unsigned long lpfn, unsigned long fgfn,
-                            unsigned int domid)
-{
-        int rc, err = 0;
-        xen_pfn_t gpfn = lpfn;
-        xen_ulong_t idx = fgfn;
-
-        struct xen_add_to_physmap_range xatp = {
-                .domid = DOMID_SELF,
-                .foreign_domid = domid,
-                .size = 1,
-                .space = XENMAPSPACE_gmfn_foreign,
-        };
-        set_xen_guest_handle(xatp.idxs, &idx);
-        set_xen_guest_handle(xatp.gpfns, &gpfn);
-        set_xen_guest_handle(xatp.errs, &err);
-
-        rc = HYPERVISOR_memory_op(XENMEM_add_to_physmap_range, &xatp);
-        if (rc < 0)
-                return rc;
-        return err;
-}
-
-static int xlate_remove_from_p2m(unsigned long spfn, int count)
-{
-        struct xen_remove_from_physmap xrp;
-        int i, rc;
-
-        for (i = 0; i < count; i++) {
-                xrp.domid = DOMID_SELF;
-                xrp.gpfn = spfn+i;
-                rc = HYPERVISOR_memory_op(XENMEM_remove_from_physmap, &xrp);
-                if (rc)
-                        break;
-        }
-        return rc;
-}
-
-struct xlate_remap_data {
-        unsigned long fgfn; /* foreign domain's gfn */
-        pgprot_t prot;
-        domid_t  domid;
-        int index;
-        struct page **pages;
-};
-
-static int xlate_map_pte_fn(pte_t *ptep, pgtable_t token, unsigned long addr,
-                            void *data)
-{
-        int rc;
-        struct xlate_remap_data *remap = data;
-        unsigned long pfn = page_to_pfn(remap->pages[remap->index++]);
-        pte_t pteval = pte_mkspecial(pfn_pte(pfn, remap->prot));
-
-        rc = xlate_add_to_p2m(pfn, remap->fgfn, remap->domid);
-        if (rc)
-                return rc;
-        native_set_pte(ptep, pteval);
-
-        return 0;
-}
-
-static int xlate_remap_gfn_range(struct vm_area_struct *vma,
-                                 unsigned long addr, unsigned long mfn,
-                                 int nr, pgprot_t prot, unsigned domid,
-                                 struct page **pages)
-{
-        int err;
-        struct xlate_remap_data pvhdata;
-
-        BUG_ON(!pages);
-
-        pvhdata.fgfn = mfn;
-        pvhdata.prot = prot;
-        pvhdata.domid = domid;
-        pvhdata.index = 0;
-        pvhdata.pages = pages;
-        err = apply_to_page_range(vma->vm_mm, addr, nr << PAGE_SHIFT,
-                                  xlate_map_pte_fn, &pvhdata);
-        flush_tlb_all();
-        return err;
-}
-#endif
-
 #define REMAP_BATCH_SIZE 16
 
 struct remap_data {
-        unsigned long mfn;
+        xen_pfn_t *mfn;
+        bool contiguous;
         pgprot_t prot;
         struct mmu_update *mmu_update;
 };
@@ -2537,7 +2449,14 @@ static int remap_area_mfn_pte_fn(pte_t *ptep, pgtable_t token,
                                  unsigned long addr, void *data)
 {
         struct remap_data *rmd = data;
-        pte_t pte = pte_mkspecial(mfn_pte(rmd->mfn++, rmd->prot));
+        pte_t pte = pte_mkspecial(mfn_pte(*rmd->mfn, rmd->prot));
+
+        /* If we have a contigious range, just update the mfn itself,
+           else update pointer to be "next mfn". */
+        if (rmd->contiguous)
+                (*rmd->mfn)++;
+        else
+                rmd->mfn++;
 
         rmd->mmu_update->ptr = virt_to_machine(ptep).maddr;
         rmd->mmu_update->val = pte_val_ma(pte);
@@ -2546,26 +2465,26 @@ static int remap_area_mfn_pte_fn(pte_t *ptep, pgtable_t token,
         return 0;
 }
 
-int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
-                               unsigned long addr,
-                               xen_pfn_t mfn, int nr,
-                               pgprot_t prot, unsigned domid,
-                               struct page **pages)
-
+static int do_remap_mfn(struct vm_area_struct *vma,
+                        unsigned long addr,
+                        xen_pfn_t *mfn, int nr,
+                        int *err_ptr, pgprot_t prot,
+                        unsigned domid,
+                        struct page **pages)
 {
+        int err = 0;
         struct remap_data rmd;
         struct mmu_update mmu_update[REMAP_BATCH_SIZE];
-        int batch;
         unsigned long range;
-        int err = 0;
+        int mapped = 0;
 
         BUG_ON(!((vma->vm_flags & (VM_PFNMAP | VM_IO)) == (VM_PFNMAP | VM_IO)));
 
         if (xen_feature(XENFEAT_auto_translated_physmap)) {
 #ifdef CONFIG_XEN_PVH
                 /* We need to update the local page tables and the xen HAP */
-                return xlate_remap_gfn_range(vma, addr, mfn, nr, prot,
-                                             domid, pages);
+                return xen_xlate_remap_gfn_array(vma, addr, mfn, nr, err_ptr,
+                                                 prot, domid, pages);
 #else
                 return -EINVAL;
 #endif
@@ -2573,9 +2492,15 @@ int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
 
         rmd.mfn = mfn;
         rmd.prot = prot;
+        /* We use the err_ptr to indicate if there we are doing a contigious
+         * mapping or a discontigious mapping. */
+        rmd.contiguous = !err_ptr;
 
         while (nr) {
-                batch = min(REMAP_BATCH_SIZE, nr);
+                int index = 0;
+                int done = 0;
+                int batch = min(REMAP_BATCH_SIZE, nr);
+                int batch_left = batch;
                 range = (unsigned long)batch << PAGE_SHIFT;
 
                 rmd.mmu_update = mmu_update;
@@ -2584,23 +2509,72 @@ int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
                 if (err)
                         goto out;
 
-                err = HYPERVISOR_mmu_update(mmu_update, batch, NULL, domid);
-                if (err < 0)
-                        goto out;
+                /* We record the error for each page that gives an error, but
+                 * continue mapping until the whole set is done */
+                do {
+                        int i;
+
+                        err = HYPERVISOR_mmu_update(&mmu_update[index],
+                                                    batch_left, &done, domid);
+
+                        /*
+                         * @err_ptr may be the same buffer as @mfn, so
+                         * only clear it after each chunk of @mfn is
+                         * used.
+                         */
+                        if (err_ptr) {
+                                for (i = index; i < index + done; i++)
+                                        err_ptr[i] = 0;
+                        }
+                        if (err < 0) {
+                                if (!err_ptr)
+                                        goto out;
+                                err_ptr[i] = err;
+                                done++; /* Skip failed frame. */
+                        } else
+                                mapped += done;
+                        batch_left -= done;
+                        index += done;
+                } while (batch_left);
 
                 nr -= batch;
                 addr += range;
+                if (err_ptr)
+                        err_ptr += batch;
         }
-
-        err = 0;
 out:
 
         xen_flush_tlb_all();
 
-        return err;
+        return err < 0 ? err : mapped;
+}
+
+int xen_remap_domain_mfn_range(struct vm_area_struct *vma,
+                               unsigned long addr,
+                               xen_pfn_t mfn, int nr,
+                               pgprot_t prot, unsigned domid,
+                               struct page **pages)
+{
+        return do_remap_mfn(vma, addr, &mfn, nr, NULL, prot, domid, pages);
 }
 EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_range);
 
+int xen_remap_domain_mfn_array(struct vm_area_struct *vma,
+                               unsigned long addr,
+                               xen_pfn_t *mfn, int nr,
+                               int *err_ptr, pgprot_t prot,
+                               unsigned domid, struct page **pages)
+{
+        /* We BUG_ON because it's a programmer error to pass a NULL err_ptr,
+         * and the consequences later is quite hard to detect what the actual
+         * cause of "wrong memory was mapped in".
+         */
+        BUG_ON(err_ptr == NULL);
+        return do_remap_mfn(vma, addr, mfn, nr, err_ptr, prot, domid, pages);
+}
+EXPORT_SYMBOL_GPL(xen_remap_domain_mfn_array);
+
+
 /* Returns: 0 success */
 int xen_unmap_domain_mfn_range(struct vm_area_struct *vma,
                                int numpgs, struct page **pages)
@@ -2609,22 +2583,7 @@ int xen_unmap_domain_mfn_range(struct vm_area_struct *vma,
                 return 0;
 
 #ifdef CONFIG_XEN_PVH
-        while (numpgs--) {
-                /*
-                 * The mmu has already cleaned up the process mmu
-                 * resources at this point (lookup_address will return
-                 * NULL).
-                 */
-                unsigned long pfn = page_to_pfn(pages[numpgs]);
-
-                xlate_remove_from_p2m(pfn, 1);
-        }
-        /*
-         * We don't need to flush tlbs because as part of
-         * xlate_remove_from_p2m, the hypervisor will do tlb flushes
-         * after removing the p2m entries from the EPT/NPT
-         */
-        return 0;
+        return xen_xlate_unmap_gfn_range(vma, numpgs, pages);
 #else
         return -EINVAL;
 #endif
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index 7413ee3706d0..86484384492e 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -90,14 +90,10 @@ static void cpu_bringup(void)
 
         set_cpu_online(cpu, true);
 
-        this_cpu_write(cpu_state, CPU_ONLINE);
-
-        wmb();
+        cpu_set_state_online(cpu);  /* Implies full memory barrier. */
 
         /* We can take interrupts now: we're officially "up". */
         local_irq_enable();
-
-        wmb();                  /* make sure everything is out */
 }
 
 /*
@@ -451,7 +447,13 @@ static int xen_cpu_up(unsigned int cpu, struct task_struct *idle)
         xen_setup_timer(cpu);
         xen_init_lock_cpu(cpu);
 
-        per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
+        /*
+         * PV VCPUs are always successfully taken down (see 'while' loop
+         * in xen_cpu_die()), so -EBUSY is an error.
+         */
+        rc = cpu_check_up_prepare(cpu);
+        if (rc)
+                return rc;
 
         /* make sure interrupts start blocked */
         per_cpu(xen_vcpu, cpu)->evtchn_upcall_mask = 1;
@@ -467,10 +469,8 @@ static int xen_cpu_up(unsigned int cpu, struct task_struct *idle)
         rc = HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL);
         BUG_ON(rc);
 
-        while(per_cpu(cpu_state, cpu) != CPU_ONLINE) {
+        while (cpu_report_state(cpu) != CPU_ONLINE)
                 HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
-                barrier();
-        }
 
         return 0;
 }
@@ -499,11 +499,11 @@ static void xen_cpu_die(unsigned int cpu)
                 schedule_timeout(HZ/10);
         }
 
-        cpu_die_common(cpu);
-
-        xen_smp_intr_free(cpu);
-        xen_uninit_lock_cpu(cpu);
-        xen_teardown_timer(cpu);
+        if (common_cpu_die(cpu) == 0) {
+                xen_smp_intr_free(cpu);
+                xen_uninit_lock_cpu(cpu);
+                xen_teardown_timer(cpu);
+        }
 }
 
 static void xen_play_dead(void) /* used only with HOTPLUG_CPU */
@@ -735,6 +735,16 @@ static void __init xen_hvm_smp_prepare_cpus(unsigned int max_cpus)
 static int xen_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
 {
         int rc;
+
+        /*
+         * This can happen if CPU was offlined earlier and
+         * offlining timed out in common_cpu_die().
+         */
+        if (cpu_report_state(cpu) == CPU_DEAD_FROZEN) {
+                xen_smp_intr_free(cpu);
+                xen_uninit_lock_cpu(cpu);
+        }
+
         /*
          * xen_smp_intr_init() needs to run before native_cpu_up()
          * so that IPI vectors are set up on the booting CPU before
@@ -756,12 +766,6 @@ static int xen_hvm_cpu_up(unsigned int cpu, struct task_struct *tidle)
         return rc;
 }
 
-static void xen_hvm_cpu_die(unsigned int cpu)
-{
-        xen_cpu_die(cpu);
-        native_cpu_die(cpu);
-}
-
 void __init xen_hvm_smp_init(void)
 {
         if (!xen_have_vector_callback)
@@ -769,7 +773,7 @@ void __init xen_hvm_smp_init(void)
         smp_ops.smp_prepare_cpus = xen_hvm_smp_prepare_cpus;
         smp_ops.smp_send_reschedule = xen_smp_send_reschedule;
         smp_ops.cpu_up = xen_hvm_cpu_up;
-        smp_ops.cpu_die = xen_hvm_cpu_die;
+        smp_ops.cpu_die = xen_cpu_die;
         smp_ops.send_call_func_ipi = xen_smp_send_call_function_ipi;
         smp_ops.send_call_func_single_ipi = xen_smp_send_call_function_single_ipi;
         smp_ops.smp_prepare_boot_cpu = xen_smp_prepare_boot_cpu;
diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c
index d9497698645a..53b4c0811f4f 100644
--- a/arch/x86/xen/suspend.c
+++ b/arch/x86/xen/suspend.c
@@ -88,7 +88,17 @@ static void xen_vcpu_notify_restore(void *data)
         tick_resume_local();
 }
 
+static void xen_vcpu_notify_suspend(void *data)
+{
+        tick_suspend_local();
+}
+
 void xen_arch_resume(void)
 {
         on_each_cpu(xen_vcpu_notify_restore, NULL, 1);
 }
+
+void xen_arch_suspend(void)
+{
+        on_each_cpu(xen_vcpu_notify_suspend, NULL, 1);
+}
diff --git a/arch/x86/xen/trace.c b/arch/x86/xen/trace.c
index 520022d1a181..a702ec2f5931 100644
--- a/arch/x86/xen/trace.c
+++ b/arch/x86/xen/trace.c
@@ -1,54 +1,12 @@
 #include <linux/ftrace.h>
 #include <xen/interface/xen.h>
+#include <xen/interface/xen-mca.h>
 
-#define N(x)    [__HYPERVISOR_##x] = "("#x")"
+#define HYPERCALL(x)    [__HYPERVISOR_##x] = "("#x")",
 static const char *xen_hypercall_names[] = {
-        N(set_trap_table),
-        N(mmu_update),
-        N(set_gdt),
-        N(stack_switch),
-        N(set_callbacks),
-        N(fpu_taskswitch),
-        N(sched_op_compat),
-        N(dom0_op),
-        N(set_debugreg),
-        N(get_debugreg),
-        N(update_descriptor),
-        N(memory_op),
-        N(multicall),
-        N(update_va_mapping),
-        N(set_timer_op),
-        N(event_channel_op_compat),
-        N(xen_version),
-        N(console_io),
-        N(physdev_op_compat),
-        N(grant_table_op),
-        N(vm_assist),
-        N(update_va_mapping_otherdomain),
-        N(iret),
-        N(vcpu_op),
-        N(set_segment_base),
-        N(mmuext_op),
-        N(acm_op),
-        N(nmi_op),
-        N(sched_op),
-        N(callback_op),
-        N(xenoprof_op),
-        N(event_channel_op),
-        N(physdev_op),
-        N(hvm_op),
-
-/* Architecture-specific hypercall definitions. */
-        N(arch_0),
-        N(arch_1),
-        N(arch_2),
-        N(arch_3),
-        N(arch_4),
-        N(arch_5),
-        N(arch_6),
-        N(arch_7),
+#include <asm/xen-hypercalls.h>
 };
-#undef N
+#undef HYPERCALL
 
 static const char *xen_hypercall_name(unsigned op)
 {
diff --git a/arch/x86/xen/xen-head.S b/arch/x86/xen/xen-head.S
index 674b222544b7..8afdfccf6086 100644
--- a/arch/x86/xen/xen-head.S
+++ b/arch/x86/xen/xen-head.S
@@ -12,6 +12,8 @@
 
 #include <xen/interface/elfnote.h>
 #include <xen/interface/features.h>
+#include <xen/interface/xen.h>
+#include <xen/interface/xen-mca.h>
 #include <asm/xen/interface.h>
 
 #ifdef CONFIG_XEN_PVH
@@ -85,59 +87,14 @@ ENTRY(xen_pvh_early_cpu_init)
 .pushsection .text
         .balign PAGE_SIZE
 ENTRY(hypercall_page)
-#define NEXT_HYPERCALL(x) \
-        ENTRY(xen_hypercall_##x) \
-        .skip 32
-
-NEXT_HYPERCALL(set_trap_table)
-NEXT_HYPERCALL(mmu_update)
-NEXT_HYPERCALL(set_gdt)
-NEXT_HYPERCALL(stack_switch)
-NEXT_HYPERCALL(set_callbacks)
-NEXT_HYPERCALL(fpu_taskswitch)
-NEXT_HYPERCALL(sched_op_compat)
-NEXT_HYPERCALL(platform_op)
-NEXT_HYPERCALL(set_debugreg)
-NEXT_HYPERCALL(get_debugreg)
-NEXT_HYPERCALL(update_descriptor)
-NEXT_HYPERCALL(ni)
-NEXT_HYPERCALL(memory_op)
-NEXT_HYPERCALL(multicall)
-NEXT_HYPERCALL(update_va_mapping)
-NEXT_HYPERCALL(set_timer_op)
-NEXT_HYPERCALL(event_channel_op_compat)
-NEXT_HYPERCALL(xen_version)
-NEXT_HYPERCALL(console_io)
-NEXT_HYPERCALL(physdev_op_compat)
-NEXT_HYPERCALL(grant_table_op)
-NEXT_HYPERCALL(vm_assist)
-NEXT_HYPERCALL(update_va_mapping_otherdomain)
-NEXT_HYPERCALL(iret)
-NEXT_HYPERCALL(vcpu_op)
-NEXT_HYPERCALL(set_segment_base)
-NEXT_HYPERCALL(mmuext_op)
-NEXT_HYPERCALL(xsm_op)
-NEXT_HYPERCALL(nmi_op)
-NEXT_HYPERCALL(sched_op)
-NEXT_HYPERCALL(callback_op)
-NEXT_HYPERCALL(xenoprof_op)
-NEXT_HYPERCALL(event_channel_op)
-NEXT_HYPERCALL(physdev_op)
-NEXT_HYPERCALL(hvm_op)
-NEXT_HYPERCALL(sysctl)
-NEXT_HYPERCALL(domctl)
-NEXT_HYPERCALL(kexec_op)
-NEXT_HYPERCALL(tmem_op) /* 38 */
-ENTRY(xen_hypercall_rsvr)
-        .skip 320
-NEXT_HYPERCALL(mca) /* 48 */
-NEXT_HYPERCALL(arch_1)
-NEXT_HYPERCALL(arch_2)
-NEXT_HYPERCALL(arch_3)
-NEXT_HYPERCALL(arch_4)
-NEXT_HYPERCALL(arch_5)
-NEXT_HYPERCALL(arch_6)
-        .balign PAGE_SIZE
+        .skip PAGE_SIZE
+
+#define HYPERCALL(n) \
+        .equ xen_hypercall_##n, hypercall_page + __HYPERVISOR_##n * 32; \
+        .type xen_hypercall_##n, @function; .size xen_hypercall_##n, 32
+#include <asm/xen-hypercalls.h>
+#undef HYPERCALL
+
 .popsection
 
         ELFNOTE(Xen, XEN_ELFNOTE_GUEST_OS,       .asciz "linux")