6 files changed, 384 insertions, 21 deletions

diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile
index 37af04f1ffd9..363286c54290 100644
--- a/drivers/xen/Makefile
+++ b/drivers/xen/Makefile
@@ -1,4 +1,4 @@
-obj-y   += grant-table.o features.o events.o
+obj-y   += grant-table.o features.o events.o manage.o
 obj-y   += xenbus/
 obj-$(CONFIG_XEN_XENCOMM)       += xencomm.o
 obj-$(CONFIG_XEN_BALLOON)       += balloon.o
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index ab25ba6cbbb9..591bc29b55f5 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -225,7 +225,7 @@ static int increase_reservation(unsigned long nr_pages)
                 page = balloon_next_page(page);
         }
 
-        reservation.extent_start = (unsigned long)frame_list;
+        set_xen_guest_handle(reservation.extent_start, frame_list);
         reservation.nr_extents   = nr_pages;
         rc = HYPERVISOR_memory_op(
                 XENMEM_populate_physmap, &reservation);
@@ -321,7 +321,7 @@ static int decrease_reservation(unsigned long nr_pages)
                 balloon_append(pfn_to_page(pfn));
         }
 
-        reservation.extent_start = (unsigned long)frame_list;
+        set_xen_guest_handle(reservation.extent_start, frame_list);
         reservation.nr_extents   = nr_pages;
         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
         BUG_ON(ret != nr_pages);
@@ -368,7 +368,7 @@ static void balloon_process(struct work_struct *work)
 }
 
 /* Resets the Xen limit, sets new target, and kicks off processing. */
-void balloon_set_new_target(unsigned long target)
+static void balloon_set_new_target(unsigned long target)
 {
         /* No need for lock. Not read-modify-write updates. */
         balloon_stats.hard_limit   = ~0UL;
@@ -483,7 +483,7 @@ static int dealloc_pte_fn(
                 .extent_order = 0,
                 .domid        = DOMID_SELF
         };
-        reservation.extent_start = (unsigned long)&mfn;
+        set_xen_guest_handle(reservation.extent_start, &mfn);
         set_pte_at(&init_mm, addr, pte, __pte_ma(0ull));
         set_phys_to_machine(__pa(addr) >> PAGE_SHIFT, INVALID_P2M_ENTRY);
         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation, &reservation);
@@ -519,7 +519,7 @@ static struct page **alloc_empty_pages_and_pagevec(int nr_pages)
                                 .extent_order = 0,
                                 .domid        = DOMID_SELF
                         };
-                        reservation.extent_start = (unsigned long)&gmfn;
+                        set_xen_guest_handle(reservation.extent_start, &gmfn);
                         ret = HYPERVISOR_memory_op(XENMEM_decrease_reservation,
                                                    &reservation);
                         if (ret == 1)
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 76e5b7386af9..332dd63750a0 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -355,7 +355,7 @@ static void unbind_from_irq(unsigned int irq)
 
         spin_lock(&irq_mapping_update_lock);
 
-        if (VALID_EVTCHN(evtchn) && (--irq_bindcount[irq] == 0)) {
+        if ((--irq_bindcount[irq] == 0) && VALID_EVTCHN(evtchn)) {
                 close.port = evtchn;
                 if (HYPERVISOR_event_channel_op(EVTCHNOP_close, &close) != 0)
                         BUG();
@@ -375,7 +375,7 @@ static void unbind_from_irq(unsigned int irq)
                 evtchn_to_irq[evtchn] = -1;
                 irq_info[irq] = IRQ_UNBOUND;
 
-                dynamic_irq_init(irq);
+                dynamic_irq_cleanup(irq);
         }
 
         spin_unlock(&irq_mapping_update_lock);
@@ -557,6 +557,33 @@ out:
         put_cpu();
 }
 
+/* Rebind a new event channel to an existing irq. */
+void rebind_evtchn_irq(int evtchn, int irq)
+{
+        /* Make sure the irq is masked, since the new event channel
+           will also be masked. */
+        disable_irq(irq);
+
+        spin_lock(&irq_mapping_update_lock);
+
+        /* After resume the irq<->evtchn mappings are all cleared out */
+        BUG_ON(evtchn_to_irq[evtchn] != -1);
+        /* Expect irq to have been bound before,
+           so the bindcount should be non-0 */
+        BUG_ON(irq_bindcount[irq] == 0);
+
+        evtchn_to_irq[evtchn] = irq;
+        irq_info[irq] = mk_irq_info(IRQT_EVTCHN, 0, evtchn);
+
+        spin_unlock(&irq_mapping_update_lock);
+
+        /* new event channels are always bound to cpu 0 */
+        irq_set_affinity(irq, cpumask_of_cpu(0));
+
+        /* Unmask the event channel. */
+        enable_irq(irq);
+}
+
 /* Rebind an evtchn so that it gets delivered to a specific cpu */
 static void rebind_irq_to_cpu(unsigned irq, unsigned tcpu)
 {
@@ -647,6 +674,89 @@ static int retrigger_dynirq(unsigned int irq)
         return ret;
 }
 
+static void restore_cpu_virqs(unsigned int cpu)
+{
+        struct evtchn_bind_virq bind_virq;
+        int virq, irq, evtchn;
+
+        for (virq = 0; virq < NR_VIRQS; virq++) {
+                if ((irq = per_cpu(virq_to_irq, cpu)[virq]) == -1)
+                        continue;
+
+                BUG_ON(irq_info[irq].type != IRQT_VIRQ);
+                BUG_ON(irq_info[irq].index != virq);
+
+                /* Get a new binding from Xen. */
+                bind_virq.virq = virq;
+                bind_virq.vcpu = cpu;
+                if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq,
+                                                &bind_virq) != 0)
+                        BUG();
+                evtchn = bind_virq.port;
+
+                /* Record the new mapping. */
+                evtchn_to_irq[evtchn] = irq;
+                irq_info[irq] = mk_irq_info(IRQT_VIRQ, virq, evtchn);
+                bind_evtchn_to_cpu(evtchn, cpu);
+
+                /* Ready for use. */
+                unmask_evtchn(evtchn);
+        }
+}
+
+static void restore_cpu_ipis(unsigned int cpu)
+{
+        struct evtchn_bind_ipi bind_ipi;
+        int ipi, irq, evtchn;
+
+        for (ipi = 0; ipi < XEN_NR_IPIS; ipi++) {
+                if ((irq = per_cpu(ipi_to_irq, cpu)[ipi]) == -1)
+                        continue;
+
+                BUG_ON(irq_info[irq].type != IRQT_IPI);
+                BUG_ON(irq_info[irq].index != ipi);
+
+                /* Get a new binding from Xen. */
+                bind_ipi.vcpu = cpu;
+                if (HYPERVISOR_event_channel_op(EVTCHNOP_bind_ipi,
+                                                &bind_ipi) != 0)
+                        BUG();
+                evtchn = bind_ipi.port;
+
+                /* Record the new mapping. */
+                evtchn_to_irq[evtchn] = irq;
+                irq_info[irq] = mk_irq_info(IRQT_IPI, ipi, evtchn);
+                bind_evtchn_to_cpu(evtchn, cpu);
+
+                /* Ready for use. */
+                unmask_evtchn(evtchn);
+
+        }
+}
+
+void xen_irq_resume(void)
+{
+        unsigned int cpu, irq, evtchn;
+
+        init_evtchn_cpu_bindings();
+
+        /* New event-channel space is not 'live' yet. */
+        for (evtchn = 0; evtchn < NR_EVENT_CHANNELS; evtchn++)
+                mask_evtchn(evtchn);
+
+        /* No IRQ <-> event-channel mappings. */
+        for (irq = 0; irq < NR_IRQS; irq++)
+                irq_info[irq].evtchn = 0; /* zap event-channel binding */
+
+        for (evtchn = 0; evtchn < NR_EVENT_CHANNELS; evtchn++)
+                evtchn_to_irq[evtchn] = -1;
+
+        for_each_possible_cpu(cpu) {
+                restore_cpu_virqs(cpu);
+                restore_cpu_ipis(cpu);
+        }
+}
+
 static struct irq_chip xen_dynamic_chip __read_mostly = {
         .name           = "xen-dyn",
         .mask           = disable_dynirq,
diff --git a/drivers/xen/grant-table.c b/drivers/xen/grant-table.c
index 52b6b41b909d..e9e11168616a 100644
--- a/drivers/xen/grant-table.c
+++ b/drivers/xen/grant-table.c
@@ -471,14 +471,14 @@ static int gnttab_map(unsigned int start_idx, unsigned int end_idx)
         return 0;
 }
 
-static int gnttab_resume(void)
+int gnttab_resume(void)
 {
         if (max_nr_grant_frames() < nr_grant_frames)
                 return -ENOSYS;
         return gnttab_map(0, nr_grant_frames - 1);
 }
 
-static int gnttab_suspend(void)
+int gnttab_suspend(void)
 {
         arch_gnttab_unmap_shared(shared, nr_grant_frames);
         return 0;
diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
new file mode 100644
index 000000000000..5b546e365f00
--- /dev/null
+++ b/drivers/xen/manage.c
@@ -0,0 +1,252 @@
+/*
+ * 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 <linux/stop_machine.h>
+#include <linux/freezer.h>
+
+#include <xen/xenbus.h>
+#include <xen/grant_table.h>
+#include <xen/events.h>
+#include <xen/hvc-console.h>
+#include <xen/xen-ops.h>
+
+#include <asm/xen/hypercall.h>
+#include <asm/xen/page.h>
+
+enum shutdown_state {
+        SHUTDOWN_INVALID = -1,
+        SHUTDOWN_POWEROFF = 0,
+        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.  */
+         SHUTDOWN_HALT = 4,
+};
+
+/* Ignore multiple shutdown requests. */
+static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
+
+#ifdef CONFIG_PM_SLEEP
+static int xen_suspend(void *data)
+{
+        int *cancelled = data;
+        int err;
+
+        BUG_ON(!irqs_disabled());
+
+        load_cr3(swapper_pg_dir);
+
+        err = device_power_down(PMSG_SUSPEND);
+        if (err) {
+                printk(KERN_ERR "xen_suspend: device_power_down failed: %d\n",
+                       err);
+                return err;
+        }
+
+        xen_mm_pin_all();
+        gnttab_suspend();
+        xen_pre_suspend();
+
+        /*
+         * This hypercall returns 1 if suspend was cancelled
+         * or the domain was merely checkpointed, and 0 if it
+         * is resuming in a new domain.
+         */
+        *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
+
+        xen_post_suspend(*cancelled);
+        gnttab_resume();
+        xen_mm_unpin_all();
+
+        device_power_up();
+
+        if (!*cancelled) {
+                xen_irq_resume();
+                xen_console_resume();
+        }
+
+        return 0;
+}
+
+static void do_suspend(void)
+{
+        int err;
+        int cancelled = 1;
+
+        shutting_down = SHUTDOWN_SUSPEND;
+
+#ifdef CONFIG_PREEMPT
+        /* If the kernel is preemptible, we need to freeze all the processes
+           to prevent them from being in the middle of a pagetable update
+           during suspend. */
+        err = freeze_processes();
+        if (err) {
+                printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
+                return;
+        }
+#endif
+
+        err = device_suspend(PMSG_SUSPEND);
+        if (err) {
+                printk(KERN_ERR "xen suspend: device_suspend %d\n", err);
+                goto out;
+        }
+
+        printk("suspending xenbus...\n");
+        /* XXX use normal device tree? */
+        xenbus_suspend();
+
+        err = stop_machine_run(xen_suspend, &cancelled, 0);
+        if (err) {
+                printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
+                goto out;
+        }
+
+        if (!cancelled)
+                xenbus_resume();
+        else
+                xenbus_suspend_cancel();
+
+        device_resume();
+
+        /* Make sure timer events get retriggered on all CPUs */
+        clock_was_set();
+out:
+#ifdef CONFIG_PREEMPT
+        thaw_processes();
+#endif
+        shutting_down = SHUTDOWN_INVALID;
+}
+#endif  /* CONFIG_PM_SLEEP */
+
+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) {
+                shutting_down = SHUTDOWN_POWEROFF;
+                orderly_poweroff(false);
+        } else if (strcmp(str, "reboot") == 0) {
+                shutting_down = SHUTDOWN_POWEROFF; /* ? */
+                ctrl_alt_del();
+#ifdef CONFIG_PM_SLEEP
+        } else if (strcmp(str, "suspend") == 0) {
+                do_suspend();
+#endif
+        } 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/drivers/xen/xenbus/xenbus_comms.c b/drivers/xen/xenbus/xenbus_comms.c
index 6efbe3f29ca5..090c61ee8fd0 100644
--- a/drivers/xen/xenbus/xenbus_comms.c
+++ b/drivers/xen/xenbus/xenbus_comms.c
@@ -203,7 +203,6 @@ int xb_read(void *data, unsigned len)
 int xb_init_comms(void)
 {
         struct xenstore_domain_interface *intf = xen_store_interface;
-        int err;
 
         if (intf->req_prod != intf->req_cons)
                 printk(KERN_ERR "XENBUS request ring is not quiescent "
@@ -216,18 +215,20 @@ int xb_init_comms(void)
                 intf->rsp_cons = intf->rsp_prod;
         }
 
-        if (xenbus_irq)
-                unbind_from_irqhandler(xenbus_irq, &xb_waitq);
+        if (xenbus_irq) {
+                /* Already have an irq; assume we're resuming */
+                rebind_evtchn_irq(xen_store_evtchn, xenbus_irq);
+        } else {
+                int err;
+                err = bind_evtchn_to_irqhandler(xen_store_evtchn, wake_waiting,
+                                                0, "xenbus", &xb_waitq);
+                if (err <= 0) {
+                        printk(KERN_ERR "XENBUS request irq failed %i\n", err);
+                        return err;
+                }
 
-        err = bind_evtchn_to_irqhandler(
-                xen_store_evtchn, wake_waiting,
-                0, "xenbus", &xb_waitq);
-        if (err <= 0) {
-                printk(KERN_ERR "XENBUS request irq failed %i\n", err);
-                return err;
+                xenbus_irq = err;
         }
 
-        xenbus_irq = err;
-
         return 0;
 }