14 files changed, 628 insertions, 303 deletions
diff --git a/arch/x86/xen/Kconfig b/arch/x86/xen/Kconfig
index 6c388e593bc8..c2cc99580871 100644
--- a/arch/x86/xen/Kconfig
+++ b/arch/x86/xen/Kconfig
@@ -12,3 +12,13 @@ config XEN
          This is the Linux Xen port.  Enabling this will allow the
          kernel to boot in a paravirtualized environment under the
          Xen hypervisor.
+config XEN_MAX_DOMAIN_MEMORY
+       int "Maximum allowed size of a domain in gigabytes"
+       default 8
+       depends on XEN
+       help
+         The pseudo-physical to machine address array is sized
+         according to the maximum possible memory size of a Xen
+         domain.  This array uses 1 page per gigabyte, so there's no
+         need to be too stingy here.
+\ No newline at end of file
diff --git a/arch/x86/xen/Makefile b/arch/x86/xen/Makefile
index 3d8df981d5fd..2ba2d1649131 100644
--- a/arch/x86/xen/Makefile
+++ b/arch/x86/xen/Makefile
@@ -1,4 +1,4 @@
 obj-y           := enlighten.o setup.o multicalls.o mmu.o \
-                        time.o manage.o xen-asm.o grant-table.o
+                        time.o xen-asm.o grant-table.o suspend.o
 obj-$(CONFIG_SMP)       += smp.o
diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
index f09c1c69c37a..bb508456ef52 100644
--- a/arch/x86/xen/enlighten.c
+++ b/arch/x86/xen/enlighten.c
@@ -45,6 +45,7 @@
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/reboot.h>
+#include <asm/pgalloc.h>
 #include "xen-ops.h"
 #include "mmu.h"
@@ -75,13 +76,13 @@ DEFINE_PER_CPU(unsigned long, xen_current_cr3);	 /* actual vcpu cr3 */
 struct start_info *xen_start_info;
 EXPORT_SYMBOL_GPL(xen_start_info);
-static /* __initdata */ struct shared_info dummy_shared_info;
+struct shared_info xen_dummy_shared_info;
 /*
 * Point at some empty memory to start with. We map the real shared_info
 * page as soon as fixmap is up and running.
 */
-struct shared_info *HYPERVISOR_shared_info = (void *)&dummy_shared_info;
+struct shared_info *HYPERVISOR_shared_info = (void *)&xen_dummy_shared_info;
 /*
 * Flag to determine whether vcpu info placement is available on all
@@ -98,13 +99,13 @@ struct shared_info *HYPERVISOR_shared_info = (void *)&dummy_shared_info;
 */
 static int have_vcpu_info_placement = 1;
-static void __init xen_vcpu_setup(int cpu)
+static void xen_vcpu_setup(int cpu)
 {
        struct vcpu_register_vcpu_info info;
        int err;
        struct vcpu_info *vcpup;
-        BUG_ON(HYPERVISOR_shared_info == &dummy_shared_info);
+        BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
        per_cpu(xen_vcpu, cpu) = &HYPERVISOR_shared_info->vcpu_info[cpu];
        if (!have_vcpu_info_placement)
@@ -136,11 +137,41 @@ static void __init xen_vcpu_setup(int cpu)
        }
 }
+/*
+ * On restore, set the vcpu placement up again.
+ * If it fails, then we're in a bad state, since
+ * we can't back out from using it...
+ */
+void xen_vcpu_restore(void)
+{
+        if (have_vcpu_info_placement) {
+                int cpu;
+                for_each_online_cpu(cpu) {
+                        bool other_cpu = (cpu != smp_processor_id());
+                        if (other_cpu &&
+                            HYPERVISOR_vcpu_op(VCPUOP_down, cpu, NULL))
+                                BUG();
+                        xen_vcpu_setup(cpu);
+                        if (other_cpu &&
+                            HYPERVISOR_vcpu_op(VCPUOP_up, cpu, NULL))
+                                BUG();
+                }
+                BUG_ON(!have_vcpu_info_placement);
+        }
+}
 static void __init xen_banner(void)
 {
        printk(KERN_INFO "Booting paravirtualized kernel on %s\n",
               pv_info.name);
-        printk(KERN_INFO "Hypervisor signature: %s\n", xen_start_info->magic);
+        printk(KERN_INFO "Hypervisor signature: %s%s\n",
+               xen_start_info->magic,
+               xen_feature(XENFEAT_mmu_pt_update_preserve_ad) ? " (preserve-AD)" : "");
 }
 static void xen_cpuid(unsigned int *ax, unsigned int *bx,
@@ -235,13 +266,13 @@ static void xen_irq_enable(void)
 {
        struct vcpu_info *vcpu;
-        /* There's a one instruction preempt window here.  We need to
+        /* We don't need to worry about being preempted here, since
-           make sure we're don't switch CPUs between getting the vcpu
+           either a) interrupts are disabled, so no preemption, or b)
-           pointer and updating the mask. */
+           the caller is confused and is trying to re-enable interrupts
-        preempt_disable();
+           on an indeterminate processor. */
        vcpu = x86_read_percpu(xen_vcpu);
        vcpu->evtchn_upcall_mask = 0;
-        preempt_enable_no_resched();
        /* Doesn't matter if we get preempted here, because any
           pending event will get dealt with anyway. */
@@ -254,7 +285,7 @@ static void xen_irq_enable(void)
 static void xen_safe_halt(void)
 {
        /* Blocking includes an implicit local_irq_enable(). */
-        if (HYPERVISOR_sched_op(SCHEDOP_block, 0) != 0)
+        if (HYPERVISOR_sched_op(SCHEDOP_block, NULL) != 0)
                BUG();
 }
@@ -607,6 +638,30 @@ static void xen_flush_tlb_others(const cpumask_t *cpus, struct mm_struct *mm,
        xen_mc_issue(PARAVIRT_LAZY_MMU);
 }
+static void xen_clts(void)
+{
+        struct multicall_space mcs;
+        mcs = xen_mc_entry(0);
+        MULTI_fpu_taskswitch(mcs.mc, 0);
+        xen_mc_issue(PARAVIRT_LAZY_CPU);
+}
+static void xen_write_cr0(unsigned long cr0)
+{
+        struct multicall_space mcs;
+        /* Only pay attention to cr0.TS; everything else is
+           ignored. */
+        mcs = xen_mc_entry(0);
+        MULTI_fpu_taskswitch(mcs.mc, (cr0 & X86_CR0_TS) != 0);
+        xen_mc_issue(PARAVIRT_LAZY_CPU);
+}
 static void xen_write_cr2(unsigned long cr2)
 {
        x86_read_percpu(xen_vcpu)->arch.cr2 = cr2;
@@ -624,8 +679,10 @@ static unsigned long xen_read_cr2_direct(void)
 static void xen_write_cr4(unsigned long cr4)
 {
-        /* Just ignore cr4 changes; Xen doesn't allow us to do
+        cr4 &= ~X86_CR4_PGE;
-           anything anyway. */
+        cr4 &= ~X86_CR4_PSE;
+        native_write_cr4(cr4);
 }
 static unsigned long xen_read_cr3(void)
@@ -831,7 +888,7 @@ static __init void xen_pagetable_setup_start(pgd_t *base)
                          PFN_DOWN(__pa(xen_start_info->pt_base)));
 }
-static __init void setup_shared_info(void)
+void xen_setup_shared_info(void)
 {
        if (!xen_feature(XENFEAT_auto_translated_physmap)) {
                unsigned long addr = fix_to_virt(FIX_PARAVIRT_BOOTMAP);
@@ -854,6 +911,8 @@ static __init void setup_shared_info(void)
        /* In UP this is as good a place as any to set up shared info */
        xen_setup_vcpu_info_placement();
 #endif
+        xen_setup_mfn_list_list();
 }
 static __init void xen_pagetable_setup_done(pgd_t *base)
@@ -866,15 +925,23 @@ static __init void xen_pagetable_setup_done(pgd_t *base)
        pv_mmu_ops.release_pmd = xen_release_pmd;
        pv_mmu_ops.set_pte = xen_set_pte;
-        setup_shared_info();
+        xen_setup_shared_info();
        /* Actually pin the pagetable down, but we can't set PG_pinned
           yet because the page structures don't exist yet. */
        pin_pagetable_pfn(MMUEXT_PIN_L3_TABLE, PFN_DOWN(__pa(base)));
 }
+static __init void xen_post_allocator_init(void)
+{
+        pv_mmu_ops.set_pmd = xen_set_pmd;
+        pv_mmu_ops.set_pud = xen_set_pud;
+        xen_mark_init_mm_pinned();
+}
 /* This is called once we have the cpu_possible_map */
-void __init xen_setup_vcpu_info_placement(void)
+void xen_setup_vcpu_info_placement(void)
 {
        int cpu;
@@ -947,6 +1014,33 @@ static unsigned xen_patch(u8 type, u16 clobbers, void *insnbuf,
        return ret;
 }
+static void xen_set_fixmap(unsigned idx, unsigned long phys, pgprot_t prot)
+{
+        pte_t pte;
+        phys >>= PAGE_SHIFT;
+        switch (idx) {
+        case FIX_BTMAP_END ... FIX_BTMAP_BEGIN:
+#ifdef CONFIG_X86_F00F_BUG
+        case FIX_F00F_IDT:
+#endif
+        case FIX_WP_TEST:
+        case FIX_VDSO:
+#ifdef CONFIG_X86_LOCAL_APIC
+        case FIX_APIC_BASE:     /* maps dummy local APIC */
+#endif
+                pte = pfn_pte(phys, prot);
+                break;
+        default:
+                pte = mfn_pte(phys, prot);
+                break;
+        }
+        __native_set_fixmap(idx, pte);
+}
 static const struct pv_info xen_info __initdata = {
        .paravirt_enabled = 1,
        .shared_kernel_pmd = 0,
@@ -960,7 +1054,7 @@ static const struct pv_init_ops xen_init_ops __initdata = {
        .banner = xen_banner,
        .memory_setup = xen_memory_setup,
        .arch_setup = xen_arch_setup,
-        .post_allocator_init = xen_mark_init_mm_pinned,
+        .post_allocator_init = xen_post_allocator_init,
 };
 static const struct pv_time_ops xen_time_ops __initdata = {
@@ -968,7 +1062,7 @@ static const struct pv_time_ops xen_time_ops __initdata = {
        .set_wallclock = xen_set_wallclock,
        .get_wallclock = xen_get_wallclock,
-        .get_cpu_khz = xen_cpu_khz,
+        .get_tsc_khz = xen_tsc_khz,
        .sched_clock = xen_sched_clock,
 };
@@ -978,10 +1072,10 @@ static const struct pv_cpu_ops xen_cpu_ops __initdata = {
        .set_debugreg = xen_set_debugreg,
        .get_debugreg = xen_get_debugreg,
-        .clts = native_clts,
+        .clts = xen_clts,
        .read_cr0 = native_read_cr0,
-        .write_cr0 = native_write_cr0,
+        .write_cr0 = xen_write_cr0,
        .read_cr4 = native_read_cr4,
        .read_cr4_safe = native_read_cr4_safe,
@@ -995,7 +1089,7 @@ static const struct pv_cpu_ops xen_cpu_ops __initdata = {
        .read_pmc = native_read_pmc,
        .iret = xen_iret,
-        .irq_enable_syscall_ret = xen_sysexit,
+        .irq_enable_sysexit = xen_sysexit,
        .load_tr_desc = paravirt_nop,
        .set_ldt = xen_set_ldt,
@@ -1029,6 +1123,9 @@ static const struct pv_irq_ops xen_irq_ops __initdata = {
        .irq_enable = xen_irq_enable,
        .safe_halt = xen_safe_halt,
        .halt = xen_halt,
+#ifdef CONFIG_X86_64
+        .adjust_exception_frame = paravirt_nop,
+#endif
 };
 static const struct pv_apic_ops xen_apic_ops __initdata = {
@@ -1060,6 +1157,9 @@ static const struct pv_mmu_ops xen_mmu_ops __initdata = {
        .pte_update = paravirt_nop,
        .pte_update_defer = paravirt_nop,
+        .pgd_alloc = __paravirt_pgd_alloc,
+        .pgd_free = paravirt_nop,
        .alloc_pte = xen_alloc_pte_init,
        .release_pte = xen_release_pte_init,
        .alloc_pmd = xen_alloc_pte_init,
@@ -1072,9 +1172,13 @@ static const struct pv_mmu_ops xen_mmu_ops __initdata = {
        .set_pte = NULL,        /* see xen_pagetable_setup_* */
        .set_pte_at = xen_set_pte_at,
-        .set_pmd = xen_set_pmd,
+        .set_pmd = xen_set_pmd_hyper,
+        .ptep_modify_prot_start = __ptep_modify_prot_start,
+        .ptep_modify_prot_commit = __ptep_modify_prot_commit,
        .pte_val = xen_pte_val,
+        .pte_flags = native_pte_val,
        .pgd_val = xen_pgd_val,
        .make_pte = xen_make_pte,
@@ -1082,7 +1186,7 @@ static const struct pv_mmu_ops xen_mmu_ops __initdata = {
        .set_pte_atomic = xen_set_pte_atomic,
        .set_pte_present = xen_set_pte_at,
-        .set_pud = xen_set_pud,
+        .set_pud = xen_set_pud_hyper,
        .pte_clear = xen_pte_clear,
        .pmd_clear = xen_pmd_clear,
@@ -1097,6 +1201,8 @@ static const struct pv_mmu_ops xen_mmu_ops __initdata = {
                .enter = paravirt_enter_lazy_mmu,
                .leave = xen_leave_lazy,
        },
+        .set_fixmap = xen_set_fixmap,
 };
 #ifdef CONFIG_SMP
@@ -1108,17 +1214,21 @@ static const struct smp_ops xen_smp_ops __initdata = {
        .smp_send_stop = xen_smp_send_stop,
        .smp_send_reschedule = xen_smp_send_reschedule,
-        .smp_call_function_mask = xen_smp_call_function_mask,
+        .send_call_func_ipi = xen_smp_send_call_function_ipi,
+        .send_call_func_single_ipi = xen_smp_send_call_function_single_ipi,
 };
 #endif  /* CONFIG_SMP */
 static void xen_reboot(int reason)
 {
+        struct sched_shutdown r = { .reason = reason };
 #ifdef CONFIG_SMP
        smp_send_stop();
 #endif
-        if (HYPERVISOR_sched_op(SCHEDOP_shutdown, reason))
+        if (HYPERVISOR_sched_op(SCHEDOP_shutdown, &r))
                BUG();
 }
@@ -1173,6 +1283,8 @@ asmlinkage void __init xen_start_kernel(void)
        BUG_ON(memcmp(xen_start_info->magic, "xen-3", 5) != 0);
+        xen_setup_features();
        /* Install Xen paravirt ops */
        pv_info = xen_info;
        pv_init_ops = xen_init_ops;
@@ -1182,21 +1294,26 @@ asmlinkage void __init xen_start_kernel(void)
        pv_apic_ops = xen_apic_ops;
        pv_mmu_ops = xen_mmu_ops;
+        if (xen_feature(XENFEAT_mmu_pt_update_preserve_ad)) {
+                pv_mmu_ops.ptep_modify_prot_start = xen_ptep_modify_prot_start;
+                pv_mmu_ops.ptep_modify_prot_commit = xen_ptep_modify_prot_commit;
+        }
        machine_ops = xen_machine_ops;
 #ifdef CONFIG_SMP
        smp_ops = xen_smp_ops;
 #endif
-        xen_setup_features();
        /* Get mfn list */
        if (!xen_feature(XENFEAT_auto_translated_physmap))
-                phys_to_machine_mapping = (unsigned long *)xen_start_info->mfn_list;
+                xen_build_dynamic_phys_to_machine();
        pgd = (pgd_t *)xen_start_info->pt_base;
+        init_pg_tables_start = __pa(pgd);
        init_pg_tables_end = __pa(pgd) + xen_start_info->nr_pt_frames*PAGE_SIZE;
+        max_pfn_mapped = (init_pg_tables_end + 512*1024) >> PAGE_SHIFT;
        init_mm.pgd = pgd; /* use the Xen pagetables to start */
@@ -1232,9 +1349,12 @@ asmlinkage void __init xen_start_kernel(void)
                ? __pa(xen_start_info->mod_start) : 0;
        boot_params.hdr.ramdisk_size = xen_start_info->mod_len;
-        if (!is_initial_xendomain())
+        if (!is_initial_xendomain()) {
+                add_preferred_console("xenboot", 0, NULL);
+                add_preferred_console("tty", 0, NULL);
                add_preferred_console("hvc", 0, NULL);
+        }
        /* Start the world */
-        start_kernel();
+        i386_start_kernel();
 }
diff --git a/arch/x86/xen/manage.c b/arch/x86/xen/manage.c
deleted file mode 100644
index aa7af9e6abc0..000000000000
--- a/arch/x86/xen/manage.c
+++ /dev/null
@@ -1,143 +0,0 @@
-/*
- * Handle extern requests for shutdown, reboot and sysrq
- */
-#include <linux/kernel.h>
-#include <linux/err.h>
-#include <linux/reboot.h>
-#include <linux/sysrq.h>
-#include <xen/xenbus.h>
-#define SHUTDOWN_INVALID  -1
-#define SHUTDOWN_POWEROFF  0
-#define SHUTDOWN_SUSPEND   2
-/* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
- * report a crash, not be instructed to crash!
- * HALT is the same as POWEROFF, as far as we're concerned.  The tools use
- * the distinction when we return the reason code to them.
- */
-#define SHUTDOWN_HALT      4
-/* Ignore multiple shutdown requests. */
-static int shutting_down = SHUTDOWN_INVALID;
-static void shutdown_handler(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
-{
-        char *str;
-        struct xenbus_transaction xbt;
-        int err;
-        if (shutting_down != SHUTDOWN_INVALID)
-                return;
- again:
-        err = xenbus_transaction_start(&xbt);
-        if (err)
-                return;
-        str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
-        /* Ignore read errors and empty reads. */
-        if (XENBUS_IS_ERR_READ(str)) {
-                xenbus_transaction_end(xbt, 1);
-                return;
-        }
-        xenbus_write(xbt, "control", "shutdown", "");
-        err = xenbus_transaction_end(xbt, 0);
-        if (err == -EAGAIN) {
-                kfree(str);
-                goto again;
-        }
-        if (strcmp(str, "poweroff") == 0 ||
-            strcmp(str, "halt") == 0)
-                orderly_poweroff(false);
-        else if (strcmp(str, "reboot") == 0)
-                ctrl_alt_del();
-        else {
-                printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
-                shutting_down = SHUTDOWN_INVALID;
-        }
-        kfree(str);
-}
-static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
-                          unsigned int len)
-{
-        char sysrq_key = '\0';
-        struct xenbus_transaction xbt;
-        int err;
- again:
-        err = xenbus_transaction_start(&xbt);
-        if (err)
-                return;
-        if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
-                printk(KERN_ERR "Unable to read sysrq code in "
-                       "control/sysrq\n");
-                xenbus_transaction_end(xbt, 1);
-                return;
-        }
-        if (sysrq_key != '\0')
-                xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
-        err = xenbus_transaction_end(xbt, 0);
-        if (err == -EAGAIN)
-                goto again;
-        if (sysrq_key != '\0')
-                handle_sysrq(sysrq_key, NULL);
-}
-static struct xenbus_watch shutdown_watch = {
-        .node = "control/shutdown",
-        .callback = shutdown_handler
-};
-static struct xenbus_watch sysrq_watch = {
-        .node = "control/sysrq",
-        .callback = sysrq_handler
-};
-static int setup_shutdown_watcher(void)
-{
-        int err;
-        err = register_xenbus_watch(&shutdown_watch);
-        if (err) {
-                printk(KERN_ERR "Failed to set shutdown watcher\n");
-                return err;
-        }
-        err = register_xenbus_watch(&sysrq_watch);
-        if (err) {
-                printk(KERN_ERR "Failed to set sysrq watcher\n");
-                return err;
-        }
-        return 0;
-}
-static int shutdown_event(struct notifier_block *notifier,
-                          unsigned long event,
-                          void *data)
-{
-        setup_shutdown_watcher();
-        return NOTIFY_DONE;
-}
-static int __init setup_shutdown_event(void)
-{
-        static struct notifier_block xenstore_notifier = {
-                .notifier_call = shutdown_event
-        };
-        register_xenstore_notifier(&xenstore_notifier);
-        return 0;
-}
-subsys_initcall(setup_shutdown_event);
diff --git a/arch/x86/xen/mmu.c b/arch/x86/xen/mmu.c
index 4e527e7893a8..ff0aa74afaa1 100644
--- a/arch/x86/xen/mmu.c
+++ b/arch/x86/xen/mmu.c
@@ -56,6 +56,131 @@
 #include "multicalls.h"
 #include "mmu.h"
+#define P2M_ENTRIES_PER_PAGE    (PAGE_SIZE / sizeof(unsigned long))
+#define TOP_ENTRIES             (MAX_DOMAIN_PAGES / P2M_ENTRIES_PER_PAGE)
+/* Placeholder for holes in the address space */
+static unsigned long p2m_missing[P2M_ENTRIES_PER_PAGE]
+        __attribute__((section(".data.page_aligned"))) =
+                { [ 0 ... P2M_ENTRIES_PER_PAGE-1 ] = ~0UL };
+ /* Array of pointers to pages containing p2m entries */
+static unsigned long *p2m_top[TOP_ENTRIES]
+        __attribute__((section(".data.page_aligned"))) =
+                { [ 0 ... TOP_ENTRIES - 1] = &p2m_missing[0] };
+/* Arrays of p2m arrays expressed in mfns used for save/restore */
+static unsigned long p2m_top_mfn[TOP_ENTRIES]
+        __attribute__((section(".bss.page_aligned")));
+static unsigned long p2m_top_mfn_list[
+                        PAGE_ALIGN(TOP_ENTRIES / P2M_ENTRIES_PER_PAGE)]
+        __attribute__((section(".bss.page_aligned")));
+static inline unsigned p2m_top_index(unsigned long pfn)
+{
+        BUG_ON(pfn >= MAX_DOMAIN_PAGES);
+        return pfn / P2M_ENTRIES_PER_PAGE;
+}
+static inline unsigned p2m_index(unsigned long pfn)
+{
+        return pfn % P2M_ENTRIES_PER_PAGE;
+}
+/* Build the parallel p2m_top_mfn structures */
+void xen_setup_mfn_list_list(void)
+{
+        unsigned pfn, idx;
+        for(pfn = 0; pfn < MAX_DOMAIN_PAGES; pfn += P2M_ENTRIES_PER_PAGE) {
+                unsigned topidx = p2m_top_index(pfn);
+                p2m_top_mfn[topidx] = virt_to_mfn(p2m_top[topidx]);
+        }
+        for(idx = 0; idx < ARRAY_SIZE(p2m_top_mfn_list); idx++) {
+                unsigned topidx = idx * P2M_ENTRIES_PER_PAGE;
+                p2m_top_mfn_list[idx] = virt_to_mfn(&p2m_top_mfn[topidx]);
+        }
+        BUG_ON(HYPERVISOR_shared_info == &xen_dummy_shared_info);
+        HYPERVISOR_shared_info->arch.pfn_to_mfn_frame_list_list =
+                virt_to_mfn(p2m_top_mfn_list);
+        HYPERVISOR_shared_info->arch.max_pfn = xen_start_info->nr_pages;
+}
+/* Set up p2m_top to point to the domain-builder provided p2m pages */
+void __init xen_build_dynamic_phys_to_machine(void)
+{
+        unsigned long *mfn_list = (unsigned long *)xen_start_info->mfn_list;
+        unsigned long max_pfn = min(MAX_DOMAIN_PAGES, xen_start_info->nr_pages);
+        unsigned pfn;
+        for(pfn = 0; pfn < max_pfn; pfn += P2M_ENTRIES_PER_PAGE) {
+                unsigned topidx = p2m_top_index(pfn);
+                p2m_top[topidx] = &mfn_list[pfn];
+        }
+}
+unsigned long get_phys_to_machine(unsigned long pfn)
+{
+        unsigned topidx, idx;
+        if (unlikely(pfn >= MAX_DOMAIN_PAGES))
+                return INVALID_P2M_ENTRY;
+        topidx = p2m_top_index(pfn);
+        idx = p2m_index(pfn);
+        return p2m_top[topidx][idx];
+}
+EXPORT_SYMBOL_GPL(get_phys_to_machine);
+static void alloc_p2m(unsigned long **pp, unsigned long *mfnp)
+{
+        unsigned long *p;
+        unsigned i;
+        p = (void *)__get_free_page(GFP_KERNEL | __GFP_NOFAIL);
+        BUG_ON(p == NULL);
+        for(i = 0; i < P2M_ENTRIES_PER_PAGE; i++)
+                p[i] = INVALID_P2M_ENTRY;
+        if (cmpxchg(pp, p2m_missing, p) != p2m_missing)
+                free_page((unsigned long)p);
+        else
+                *mfnp = virt_to_mfn(p);
+}
+void set_phys_to_machine(unsigned long pfn, unsigned long mfn)
+{
+        unsigned topidx, idx;
+        if (unlikely(xen_feature(XENFEAT_auto_translated_physmap))) {
+                BUG_ON(pfn != mfn && mfn != INVALID_P2M_ENTRY);
+                return;
+        }
+        if (unlikely(pfn >= MAX_DOMAIN_PAGES)) {
+                BUG_ON(mfn != INVALID_P2M_ENTRY);
+                return;
+        }
+        topidx = p2m_top_index(pfn);
+        if (p2m_top[topidx] == p2m_missing) {
+                /* no need to allocate a page to store an invalid entry */
+                if (mfn == INVALID_P2M_ENTRY)
+                        return;
+                alloc_p2m(&p2m_top[topidx], &p2m_top_mfn[topidx]);
+        }
+        idx = p2m_index(pfn);
+        p2m_top[topidx][idx] = mfn;
+}
 xmaddr_t arbitrary_virt_to_machine(unsigned long address)
 {
        unsigned int level;
@@ -98,24 +223,60 @@ void make_lowmem_page_readwrite(void *vaddr)
 }
-void xen_set_pmd(pmd_t *ptr, pmd_t val)
+static bool page_pinned(void *ptr)
+{
+        struct page *page = virt_to_page(ptr);
+        return PagePinned(page);
+}
+static void extend_mmu_update(const struct mmu_update *update)
 {
        struct multicall_space mcs;
        struct mmu_update *u;
-        preempt_disable();
+        mcs = xen_mc_extend_args(__HYPERVISOR_mmu_update, sizeof(*u));
+        if (mcs.mc != NULL)
+                mcs.mc->args[1]++;
+        else {
+                mcs = __xen_mc_entry(sizeof(*u));
+                MULTI_mmu_update(mcs.mc, mcs.args, 1, NULL, DOMID_SELF);
+        }
-        mcs = xen_mc_entry(sizeof(*u));
        u = mcs.args;
-        u->ptr = virt_to_machine(ptr).maddr;
+        *u = *update;
-        u->val = pmd_val_ma(val);
+}
-        MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
+void xen_set_pmd_hyper(pmd_t *ptr, pmd_t val)
+{
+        struct mmu_update u;
+        preempt_disable();
+        xen_mc_batch();
+        u.ptr = virt_to_machine(ptr).maddr;
+        u.val = pmd_val_ma(val);
+        extend_mmu_update(&u);
        xen_mc_issue(PARAVIRT_LAZY_MMU);
        preempt_enable();
 }
+void xen_set_pmd(pmd_t *ptr, pmd_t val)
+{
+        /* If page is not pinned, we can just update the entry
+           directly */
+        if (!page_pinned(ptr)) {
+                *ptr = val;
+                return;
+        }
+        xen_set_pmd_hyper(ptr, val);
+}
 /*
 * Associate a virtual page frame with a given physical page frame
 * and protection flags for that frame.
@@ -179,6 +340,26 @@ out:
                preempt_enable();
 }
+pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
+{
+        /* Just return the pte as-is.  We preserve the bits on commit */
+        return *ptep;
+}
+void xen_ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
+                                 pte_t *ptep, pte_t pte)
+{
+        struct mmu_update u;
+        xen_mc_batch();
+        u.ptr = virt_to_machine(ptep).maddr | MMU_PT_UPDATE_PRESERVE_AD;
+        u.val = pte_val_ma(pte);
+        extend_mmu_update(&u);
+        xen_mc_issue(PARAVIRT_LAZY_MMU);
+}
 /* Assume pteval_t is equivalent to all the other *val_t types. */
 static pteval_t pte_mfn_to_pfn(pteval_t val)
 {
@@ -229,24 +410,35 @@ pmdval_t xen_pmd_val(pmd_t pmd)
        return pte_mfn_to_pfn(pmd.pmd);
 }
-void xen_set_pud(pud_t *ptr, pud_t val)
+void xen_set_pud_hyper(pud_t *ptr, pud_t val)
 {
-        struct multicall_space mcs;
+        struct mmu_update u;
-        struct mmu_update *u;
        preempt_disable();
-        mcs = xen_mc_entry(sizeof(*u));
+        xen_mc_batch();
-        u = mcs.args;
-        u->ptr = virt_to_machine(ptr).maddr;
+        u.ptr = virt_to_machine(ptr).maddr;
-        u->val = pud_val_ma(val);
+        u.val = pud_val_ma(val);
-        MULTI_mmu_update(mcs.mc, u, 1, NULL, DOMID_SELF);
+        extend_mmu_update(&u);
        xen_mc_issue(PARAVIRT_LAZY_MMU);
        preempt_enable();
 }
+void xen_set_pud(pud_t *ptr, pud_t val)
+{
+        /* If page is not pinned, we can just update the entry
+           directly */
+        if (!page_pinned(ptr)) {
+                *ptr = val;
+                return;
+        }
+        xen_set_pud_hyper(ptr, val);
+}
 void xen_set_pte(pte_t *ptep, pte_t pte)
 {
        ptep->pte_high = pte.pte_high;
@@ -268,7 +460,7 @@ void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
 void xen_pmd_clear(pmd_t *pmdp)
 {
-        xen_set_pmd(pmdp, __pmd(0));
+        set_pmd(pmdp, __pmd(0));
 }
 pmd_t xen_make_pmd(pmdval_t pmd)
@@ -441,6 +633,29 @@ void xen_pgd_pin(pgd_t *pgd)
        xen_mc_issue(0);
 }
+/*
+ * On save, we need to pin all pagetables to make sure they get their
+ * mfns turned into pfns.  Search the list for any unpinned pgds and pin
+ * them (unpinned pgds are not currently in use, probably because the
+ * process is under construction or destruction).
+ */
+void xen_mm_pin_all(void)
+{
+        unsigned long flags;
+        struct page *page;
+        spin_lock_irqsave(&pgd_lock, flags);
+        list_for_each_entry(page, &pgd_list, lru) {
+                if (!PagePinned(page)) {
+                        xen_pgd_pin((pgd_t *)page_address(page));
+                        SetPageSavePinned(page);
+                }
+        }
+        spin_unlock_irqrestore(&pgd_lock, flags);
+}
 /* The init_mm pagetable is really pinned as soon as its created, but
   that's before we have page structures to store the bits.  So do all
   the book-keeping now. */
@@ -498,6 +713,29 @@ static void xen_pgd_unpin(pgd_t *pgd)
        xen_mc_issue(0);
 }
+/*
+ * On resume, undo any pinning done at save, so that the rest of the
+ * kernel doesn't see any unexpected pinned pagetables.
+ */
+void xen_mm_unpin_all(void)
+{
+        unsigned long flags;
+        struct page *page;
+        spin_lock_irqsave(&pgd_lock, flags);
+        list_for_each_entry(page, &pgd_list, lru) {
+                if (PageSavePinned(page)) {
+                        BUG_ON(!PagePinned(page));
+                        printk("unpinning pinned %p\n", page_address(page));
+                        xen_pgd_unpin((pgd_t *)page_address(page));
+                        ClearPageSavePinned(page);
+                }
+        }
+        spin_unlock_irqrestore(&pgd_lock, flags);
+}
 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next)
 {
        spin_lock(&next->page_table_lock);
@@ -558,7 +796,7 @@ static void drop_mm_ref(struct mm_struct *mm)
        }
        if (!cpus_empty(mask))
-                xen_smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
+                smp_call_function_mask(mask, drop_other_mm_ref, mm, 1);
 }
 #else
 static void drop_mm_ref(struct mm_struct *mm)
@@ -591,7 +829,7 @@ void xen_exit_mmap(struct mm_struct *mm)
        spin_lock(&mm->page_table_lock);
        /* pgd may not be pinned in the error exit path of execve */
-        if (PagePinned(virt_to_page(mm->pgd)))
+        if (page_pinned(mm->pgd))
                xen_pgd_unpin(mm->pgd);
        spin_unlock(&mm->page_table_lock);
diff --git a/arch/x86/xen/mmu.h b/arch/x86/xen/mmu.h
index 5fe961caffd4..297bf9f5b8bc 100644
--- a/arch/x86/xen/mmu.h
+++ b/arch/x86/xen/mmu.h
@@ -25,10 +25,6 @@ enum pt_level {
 void set_pte_mfn(unsigned long vaddr, unsigned long pfn, pgprot_t flags);
-void xen_set_pte(pte_t *ptep, pte_t pteval);
-void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
-                    pte_t *ptep, pte_t pteval);
-void xen_set_pmd(pmd_t *pmdp, pmd_t pmdval);
 void xen_activate_mm(struct mm_struct *prev, struct mm_struct *next);
 void xen_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm);
@@ -45,11 +41,19 @@ pte_t xen_make_pte(pteval_t);
 pmd_t xen_make_pmd(pmdval_t);
 pgd_t xen_make_pgd(pgdval_t);
+void xen_set_pte(pte_t *ptep, pte_t pteval);
 void xen_set_pte_at(struct mm_struct *mm, unsigned long addr,
                    pte_t *ptep, pte_t pteval);
 void xen_set_pte_atomic(pte_t *ptep, pte_t pte);
+void xen_set_pmd(pmd_t *pmdp, pmd_t pmdval);
 void xen_set_pud(pud_t *ptr, pud_t val);
+void xen_set_pmd_hyper(pmd_t *pmdp, pmd_t pmdval);
+void xen_set_pud_hyper(pud_t *ptr, pud_t val);
 void xen_pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
 void xen_pmd_clear(pmd_t *pmdp);
+pte_t xen_ptep_modify_prot_start(struct mm_struct *mm, unsigned long addr, pte_t *ptep);
+void  xen_ptep_modify_prot_commit(struct mm_struct *mm, unsigned long addr,
+                                  pte_t *ptep, pte_t pte);
 #endif  /* _XEN_MMU_H */
diff --git a/arch/x86/xen/multicalls.c b/arch/x86/xen/multicalls.c
index 5791eb2e3750..3c63c4da7ed1 100644
--- a/arch/x86/xen/multicalls.c
+++ b/arch/x86/xen/multicalls.c
@@ -29,14 +29,14 @@
 #define MC_DEBUG        1
 #define MC_BATCH        32
-#define MC_ARGS         (MC_BATCH * 16 / sizeof(u64))
+#define MC_ARGS         (MC_BATCH * 16)
 struct mc_buffer {
        struct multicall_entry entries[MC_BATCH];
 #if MC_DEBUG
        struct multicall_entry debug[MC_BATCH];
 #endif
-        u64 args[MC_ARGS];
+        unsigned char args[MC_ARGS];
        struct callback {
                void (*fn)(void *);
                void *data;
@@ -107,20 +107,48 @@ struct multicall_space __xen_mc_entry(size_t args)
 {
        struct mc_buffer *b = &__get_cpu_var(mc_buffer);
        struct multicall_space ret;
-        unsigned argspace = (args + sizeof(u64) - 1) / sizeof(u64);
+        unsigned argidx = roundup(b->argidx, sizeof(u64));
        BUG_ON(preemptible());
-        BUG_ON(argspace > MC_ARGS);
+        BUG_ON(b->argidx > MC_ARGS);
        if (b->mcidx == MC_BATCH ||
-            (b->argidx + argspace) > MC_ARGS)
+            (argidx + args) > MC_ARGS) {
                xen_mc_flush();
+                argidx = roundup(b->argidx, sizeof(u64));
+        }
        ret.mc = &b->entries[b->mcidx];
        b->mcidx++;
+        ret.args = &b->args[argidx];
+        b->argidx = argidx + args;
+        BUG_ON(b->argidx > MC_ARGS);
+        return ret;
+}
+struct multicall_space xen_mc_extend_args(unsigned long op, size_t size)
+{
+        struct mc_buffer *b = &__get_cpu_var(mc_buffer);
+        struct multicall_space ret = { NULL, NULL };
+        BUG_ON(preemptible());
+        BUG_ON(b->argidx > MC_ARGS);
+        if (b->mcidx == 0)
+                return ret;
+        if (b->entries[b->mcidx - 1].op != op)
+                return ret;
+        if ((b->argidx + size) > MC_ARGS)
+                return ret;
+        ret.mc = &b->entries[b->mcidx - 1];
        ret.args = &b->args[b->argidx];
-        b->argidx += argspace;
+        b->argidx += size;
+        BUG_ON(b->argidx > MC_ARGS);
        return ret;
 }
diff --git a/arch/x86/xen/multicalls.h b/arch/x86/xen/multicalls.h
index 8bae996d99a3..858938241616 100644
--- a/arch/x86/xen/multicalls.h
+++ b/arch/x86/xen/multicalls.h
@@ -45,4 +45,16 @@ static inline void xen_mc_issue(unsigned mode)
 /* Set up a callback to be called when the current batch is flushed */
 void xen_mc_callback(void (*fn)(void *), void *data);
+/*
+ * Try to extend the arguments of the previous multicall command.  The
+ * previous command's op must match.  If it does, then it attempts to
+ * extend the argument space allocated to the multicall entry by
+ * arg_size bytes.
+ *
+ * The returned multicall_space will return with mc pointing to the
+ * command on success, or NULL on failure, and args pointing to the
+ * newly allocated space.
+ */
+struct multicall_space xen_mc_extend_args(unsigned long op, size_t arg_size);
 #endif /* _XEN_MULTICALLS_H */
diff --git a/arch/x86/xen/setup.c b/arch/x86/xen/setup.c
index 82517e4a752a..e0a39595bde3 100644
--- a/arch/x86/xen/setup.c
+++ b/arch/x86/xen/setup.c
@@ -13,9 +13,11 @@
 #include <asm/vdso.h>
 #include <asm/e820.h>
 #include <asm/setup.h>
+#include <asm/acpi.h>
 #include <asm/xen/hypervisor.h>
 #include <asm/xen/hypercall.h>
+#include <xen/page.h>
 #include <xen/interface/callback.h>
 #include <xen/interface/physdev.h>
 #include <xen/features.h>
@@ -27,8 +29,6 @@
 extern const char xen_hypervisor_callback[];
 extern const char xen_failsafe_callback[];
-unsigned long *phys_to_machine_mapping;
-EXPORT_SYMBOL(phys_to_machine_mapping);
 /**
 * machine_specific_memory_setup - Hook for machine specific memory setup.
@@ -38,9 +38,31 @@ char * __init xen_memory_setup(void)
 {
        unsigned long max_pfn = xen_start_info->nr_pages;
+        max_pfn = min(MAX_DOMAIN_PAGES, max_pfn);
        e820.nr_map = 0;
-        add_memory_region(0, LOWMEMSIZE(), E820_RAM);
-        add_memory_region(HIGH_MEMORY, PFN_PHYS(max_pfn)-HIGH_MEMORY, E820_RAM);
+        e820_add_region(0, PFN_PHYS(max_pfn), E820_RAM);
+        /*
+         * Even though this is normal, usable memory under Xen, reserve
+         * ISA memory anyway because too many things think they can poke
+         * about in there.
+         */
+        e820_add_region(ISA_START_ADDRESS, ISA_END_ADDRESS - ISA_START_ADDRESS,
+                        E820_RESERVED);
+        /*
+         * Reserve Xen bits:
+         *  - mfn_list
+         *  - xen_start_info
+         * See comment above "struct start_info" in <xen/interface/xen.h>
+         */
+        e820_add_region(__pa(xen_start_info->mfn_list),
+                        xen_start_info->pt_base - xen_start_info->mfn_list,
+                        E820_RESERVED);
+        sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
        return "Xen";
 }
diff --git a/arch/x86/xen/smp.c b/arch/x86/xen/smp.c
index 94e69000f982..233156f39b7f 100644
--- a/arch/x86/xen/smp.c
+++ b/arch/x86/xen/smp.c
@@ -35,28 +35,15 @@
 #include "xen-ops.h"
 #include "mmu.h"
-static cpumask_t xen_cpu_initialized_map;
+cpumask_t xen_cpu_initialized_map;
-static DEFINE_PER_CPU(int, resched_irq) = -1;
-static DEFINE_PER_CPU(int, callfunc_irq) = -1;
-static DEFINE_PER_CPU(int, debug_irq) = -1;
-/*
- * Structure and data for smp_call_function(). This is designed to minimise
- * static memory requirements. It also looks cleaner.
- */
-static DEFINE_SPINLOCK(call_lock);
-struct call_data_struct {
+static DEFINE_PER_CPU(int, resched_irq);
-        void (*func) (void *info);
+static DEFINE_PER_CPU(int, callfunc_irq);
-        void *info;
+static DEFINE_PER_CPU(int, callfuncsingle_irq);
-        atomic_t started;
+static DEFINE_PER_CPU(int, debug_irq) = -1;
-        atomic_t finished;
-        int wait;
-};
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id);
+static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id);
-static struct call_data_struct *call_data;
 /*
 * Reschedule call back. Nothing to do,
@@ -65,6 +52,12 @@ static struct call_data_struct *call_data;
 */
 static irqreturn_t xen_reschedule_interrupt(int irq, void *dev_id)
 {
+#ifdef CONFIG_X86_32
+        __get_cpu_var(irq_stat).irq_resched_count++;
+#else
+        add_pda(irq_resched_count, 1);
+#endif
        return IRQ_HANDLED;
 }
@@ -122,6 +115,17 @@ static int xen_smp_intr_init(unsigned int cpu)
                goto fail;
        per_cpu(debug_irq, cpu) = rc;
+        callfunc_name = kasprintf(GFP_KERNEL, "callfuncsingle%d", cpu);
+        rc = bind_ipi_to_irqhandler(XEN_CALL_FUNCTION_SINGLE_VECTOR,
+                                    cpu,
+                                    xen_call_function_single_interrupt,
+                                    IRQF_DISABLED|IRQF_PERCPU|IRQF_NOBALANCING,
+                                    callfunc_name,
+                                    NULL);
+        if (rc < 0)
+                goto fail;
+        per_cpu(callfuncsingle_irq, cpu) = rc;
        return 0;
 fail:
@@ -131,6 +135,9 @@ static int xen_smp_intr_init(unsigned int cpu)
                unbind_from_irqhandler(per_cpu(callfunc_irq, cpu), NULL);
        if (per_cpu(debug_irq, cpu) >= 0)
                unbind_from_irqhandler(per_cpu(debug_irq, cpu), NULL);
+        if (per_cpu(callfuncsingle_irq, cpu) >= 0)
+                unbind_from_irqhandler(per_cpu(callfuncsingle_irq, cpu), NULL);
        return rc;
 }
@@ -330,7 +337,7 @@ static void stop_self(void *v)
 void xen_smp_send_stop(void)
 {
-        smp_call_function(stop_self, NULL, 0, 0);
+        smp_call_function(stop_self, NULL, 0);
 }
 void xen_smp_send_reschedule(int cpu)
@@ -338,7 +345,6 @@ void xen_smp_send_reschedule(int cpu)
        xen_send_IPI_one(cpu, XEN_RESCHEDULE_VECTOR);
 }
 static void xen_send_IPI_mask(cpumask_t mask, enum ipi_vector vector)
 {
        unsigned cpu;
@@ -349,83 +355,42 @@ static void xen_send_IPI_mask(cpumask_t mask, enum ipi_vector vector)
                xen_send_IPI_one(cpu, vector);
 }
+void xen_smp_send_call_function_ipi(cpumask_t mask)
+{
+        int cpu;
+        xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
+        /* Make sure other vcpus get a chance to run if they need to. */
+        for_each_cpu_mask(cpu, mask) {
+                if (xen_vcpu_stolen(cpu)) {
+                        HYPERVISOR_sched_op(SCHEDOP_yield, 0);
+                        break;
+                }
+        }
+}
+void xen_smp_send_call_function_single_ipi(int cpu)
+{
+        xen_send_IPI_mask(cpumask_of_cpu(cpu), XEN_CALL_FUNCTION_SINGLE_VECTOR);
+}
 static irqreturn_t xen_call_function_interrupt(int irq, void *dev_id)
 {
-        void (*func) (void *info) = call_data->func;
-        void *info = call_data->info;
-        int wait = call_data->wait;
-        /*
-         * Notify initiating CPU that I've grabbed the data and am
-         * about to execute the function
-         */
-        mb();
-        atomic_inc(&call_data->started);
-        /*
-         * At this point the info structure may be out of scope unless wait==1
-         */
        irq_enter();
-        (*func)(info);
+        generic_smp_call_function_interrupt();
        __get_cpu_var(irq_stat).irq_call_count++;
        irq_exit();
-        if (wait) {
-                mb();           /* commit everything before setting finished */
-                atomic_inc(&call_data->finished);
-        }
        return IRQ_HANDLED;
 }
-int xen_smp_call_function_mask(cpumask_t mask, void (*func)(void *),
+static irqreturn_t xen_call_function_single_interrupt(int irq, void *dev_id)
-                               void *info, int wait)
 {
-        struct call_data_struct data;
+        irq_enter();
-        int cpus, cpu;
+        generic_smp_call_function_single_interrupt();
-        bool yield;
+        __get_cpu_var(irq_stat).irq_call_count++;
+        irq_exit();
-        /* Holding any lock stops cpus from going down. */
-        spin_lock(&call_lock);
-        cpu_clear(smp_processor_id(), mask);
-        cpus = cpus_weight(mask);
-        if (!cpus) {
-                spin_unlock(&call_lock);
-                return 0;
-        }
-        /* Can deadlock when called with interrupts disabled */
-        WARN_ON(irqs_disabled());
-        data.func = func;
-        data.info = info;
-        atomic_set(&data.started, 0);
-        data.wait = wait;
-        if (wait)
-                atomic_set(&data.finished, 0);
-        call_data = &data;
-        mb();                   /* write everything before IPI */
-        /* Send a message to other CPUs and wait for them to respond */
-        xen_send_IPI_mask(mask, XEN_CALL_FUNCTION_VECTOR);
-        /* Make sure other vcpus get a chance to run if they need to. */
-        yield = false;
-        for_each_cpu_mask(cpu, mask)
-                if (xen_vcpu_stolen(cpu))
-                        yield = true;
-        if (yield)
-                HYPERVISOR_sched_op(SCHEDOP_yield, 0);
-        /* Wait for response */
-        while (atomic_read(&data.started) != cpus ||
-               (wait && atomic_read(&data.finished) != cpus))
-                cpu_relax();
-        spin_unlock(&call_lock);
-        return 0;
+        return IRQ_HANDLED;
 }
diff --git a/arch/x86/xen/suspend.c b/arch/x86/xen/suspend.c
new file mode 100644
index 000000000000..251669a932d4
--- /dev/null
+++ b/arch/x86/xen/suspend.c
@@ -0,0 +1,45 @@
+#include <linux/types.h>
+#include <xen/interface/xen.h>
+#include <xen/grant_table.h>
+#include <xen/events.h>
+#include <asm/xen/hypercall.h>
+#include <asm/xen/page.h>
+#include "xen-ops.h"
+#include "mmu.h"
+void xen_pre_suspend(void)
+{
+        xen_start_info->store_mfn = mfn_to_pfn(xen_start_info->store_mfn);
+        xen_start_info->console.domU.mfn =
+                mfn_to_pfn(xen_start_info->console.domU.mfn);
+        BUG_ON(!irqs_disabled());
+        HYPERVISOR_shared_info = &xen_dummy_shared_info;
+        if (HYPERVISOR_update_va_mapping(fix_to_virt(FIX_PARAVIRT_BOOTMAP),
+                                         __pte_ma(0), 0))
+                BUG();
+}
+void xen_post_suspend(int suspend_cancelled)
+{
+        xen_setup_shared_info();
+        if (suspend_cancelled) {
+                xen_start_info->store_mfn =
+                        pfn_to_mfn(xen_start_info->store_mfn);
+                xen_start_info->console.domU.mfn =
+                        pfn_to_mfn(xen_start_info->console.domU.mfn);
+        } else {
+#ifdef CONFIG_SMP
+                xen_cpu_initialized_map = cpu_online_map;
+#endif
+                xen_vcpu_restore();
+                xen_timer_resume();
+        }
+}
diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
index 41e217503c96..685b77470fc3 100644
--- a/arch/x86/xen/time.c
+++ b/arch/x86/xen/time.c
@@ -197,8 +197,8 @@ unsigned long long xen_sched_clock(void)
 }
-/* Get the CPU speed from Xen */
+/* Get the TSC speed from Xen */
-unsigned long xen_cpu_khz(void)
+unsigned long xen_tsc_khz(void)
 {
        u64 xen_khz = 1000000ULL << 32;
        const struct pvclock_vcpu_time_info *info =
@@ -459,6 +459,19 @@ void xen_setup_cpu_clockevents(void)
        clockevents_register_device(&__get_cpu_var(xen_clock_events));
 }
+void xen_timer_resume(void)
+{
+        int cpu;
+        if (xen_clockevent != &xen_vcpuop_clockevent)
+                return;
+        for_each_online_cpu(cpu) {
+                if (HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
+                        BUG();
+        }
+}
 __init void xen_time_init(void)
 {
        int cpu = smp_processor_id();
diff --git a/arch/x86/xen/xen-head.S b/arch/x86/xen/xen-head.S
index 6ec3b4f7719b..7c0cf6320a0a 100644
--- a/arch/x86/xen/xen-head.S
+++ b/arch/x86/xen/xen-head.S
@@ -7,6 +7,7 @@
 #include <linux/init.h>
 #include <asm/boot.h>
 #include <xen/interface/elfnote.h>
+#include <asm/xen/interface.h>
        __INIT
 ENTRY(startup_xen)
@@ -32,5 +33,9 @@ ENTRY(hypercall_page)
        ELFNOTE(Xen, XEN_ELFNOTE_FEATURES,       .asciz "!writable_page_tables|pae_pgdir_above_4gb")
        ELFNOTE(Xen, XEN_ELFNOTE_PAE_MODE,       .asciz "yes")
        ELFNOTE(Xen, XEN_ELFNOTE_LOADER,         .asciz "generic")
+        ELFNOTE(Xen, XEN_ELFNOTE_L1_MFN_VALID,
+                .quad _PAGE_PRESENT; .quad _PAGE_PRESENT)
+        ELFNOTE(Xen, XEN_ELFNOTE_SUSPEND_CANCEL, .long 1)
+        ELFNOTE(Xen, XEN_ELFNOTE_HV_START_LOW,   .long __HYPERVISOR_VIRT_START)
 #endif /*CONFIG_XEN */
diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h
index f1063ae08037..6f4b1045c1c2 100644
--- a/arch/x86/xen/xen-ops.h
+++ b/arch/x86/xen/xen-ops.h
@@ -9,26 +9,35 @@
 extern const char xen_hypervisor_callback[];
 extern const char xen_failsafe_callback[];
+struct trap_info;
 void xen_copy_trap_info(struct trap_info *traps);
 DECLARE_PER_CPU(unsigned long, xen_cr3);
 DECLARE_PER_CPU(unsigned long, xen_current_cr3);
 extern struct start_info *xen_start_info;
+extern struct shared_info xen_dummy_shared_info;
 extern struct shared_info *HYPERVISOR_shared_info;
+void xen_setup_mfn_list_list(void);
+void xen_setup_shared_info(void);
 char * __init xen_memory_setup(void);
 void __init xen_arch_setup(void);
 void __init xen_init_IRQ(void);
 void xen_enable_sysenter(void);
+void xen_vcpu_restore(void);
+void __init xen_build_dynamic_phys_to_machine(void);
 void xen_setup_timer(int cpu);
 void xen_setup_cpu_clockevents(void);
-unsigned long xen_cpu_khz(void);
+unsigned long xen_tsc_khz(void);
 void __init xen_time_init(void);
 unsigned long xen_get_wallclock(void);
 int xen_set_wallclock(unsigned long time);
 unsigned long long xen_sched_clock(void);
+void xen_timer_resume(void);
 irqreturn_t xen_debug_interrupt(int irq, void *dev_id);
@@ -46,13 +55,10 @@ void xen_smp_cpus_done(unsigned int max_cpus);
 void xen_smp_send_stop(void);
 void xen_smp_send_reschedule(int cpu);
-int xen_smp_call_function (void (*func) (void *info), void *info, int nonatomic,
+void xen_smp_send_call_function_ipi(cpumask_t mask);
-                           int wait);
+void xen_smp_send_call_function_single_ipi(int cpu);
-int xen_smp_call_function_single(int cpu, void (*func) (void *info), void *info,
-                                 int nonatomic, int wait);
-int xen_smp_call_function_mask(cpumask_t mask, void (*func)(void *),
+extern cpumask_t xen_cpu_initialized_map;
-                               void *info, int wait);
 /* Declare an asm function, along with symbols needed to make it