drivers/xen/manage.c

   1 /*
   2  * Handle extern requests for shutdown, reboot and sysrq
   3  */
   4 #include <linux/kernel.h>
   5 #include <linux/err.h>
   6 #include <linux/reboot.h>
   7 #include <linux/sysrq.h>
   8 #include <linux/stop_machine.h>
   9 #include <linux/freezer.h>
  10
  11 #include <xen/xenbus.h>
  12 #include <xen/grant_table.h>
  13 #include <xen/events.h>
  14 #include <xen/hvc-console.h>
  15 #include <xen/xen-ops.h>
  16
  17 #include <asm/xen/hypercall.h>
  18 #include <asm/xen/page.h>
  19
  20 enum shutdown_state {
  21         SHUTDOWN_INVALID = -1,
  22         SHUTDOWN_POWEROFF = 0,
  23         SHUTDOWN_SUSPEND = 2,
  24         /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
  25            report a crash, not be instructed to crash!
  26            HALT is the same as POWEROFF, as far as we're concerned.  The tools use
  27            the distinction when we return the reason code to them.  */
  28          SHUTDOWN_HALT = 4,
  29 };
  30
  31 /* Ignore multiple shutdown requests. */
  32 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
  33
  34 #ifdef CONFIG_PM_SLEEP
  35 static int xen_suspend(void *data)
  36 {
  37         int *cancelled = data;
  38         int err;
  39
  40         BUG_ON(!irqs_disabled());
  41
  42         err = device_power_down(PMSG_SUSPEND);
  43         if (err) {
  44                 printk(KERN_ERR "xen_suspend: device_power_down failed: %d\n",
  45                        err);
  46                 return err;
  47         }
  48
  49         xen_mm_pin_all();
  50         gnttab_suspend();
  51         xen_pre_suspend();
  52
  53         /*
  54          * This hypercall returns 1 if suspend was cancelled
  55          * or the domain was merely checkpointed, and 0 if it
  56          * is resuming in a new domain.
  57          */
  58         *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
  59
  60         xen_post_suspend(*cancelled);
  61         gnttab_resume();
  62         xen_mm_unpin_all();
  63
  64         device_power_up(PMSG_RESUME);
  65
  66         if (!*cancelled) {
  67                 xen_irq_resume();
  68                 xen_console_resume();
  69                 xen_timer_resume();
  70         }
  71
  72         return 0;
  73 }
  74
  75 static void do_suspend(void)
  76 {
  77         int err;
  78         int cancelled = 1;
  79
  80         shutting_down = SHUTDOWN_SUSPEND;
  81
  82 #ifdef CONFIG_PREEMPT
  83         /* If the kernel is preemptible, we need to freeze all the processes
  84            to prevent them from being in the middle of a pagetable update
  85            during suspend. */
  86         err = freeze_processes();
  87         if (err) {
  88                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
  89                 return;
  90         }
  91 #endif
  92
  93         err = device_suspend(PMSG_SUSPEND);
  94         if (err) {
  95                 printk(KERN_ERR "xen suspend: device_suspend %d\n", err);
  96                 goto out;
  97         }
  98
  99         printk("suspending xenbus...\n");
 100         /* XXX use normal device tree? */
 101         xenbus_suspend();
 102
 103         err = stop_machine(xen_suspend, &cancelled, &cpumask_of_cpu(0));
 104         if (err) {
 105                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
 106                 goto out;
 107         }
 108
 109         if (!cancelled) {
 110                 xen_arch_resume();
 111                 xenbus_resume();
 112         } else
 113                 xenbus_suspend_cancel();
 114
 115         device_resume(PMSG_RESUME);
 116
 117         /* Make sure timer events get retriggered on all CPUs */
 118         clock_was_set();
 119 out:
 120 #ifdef CONFIG_PREEMPT
 121         thaw_processes();
 122 #endif
 123         shutting_down = SHUTDOWN_INVALID;
 124 }
 125 #endif  /* CONFIG_PM_SLEEP */
 126
 127 static void shutdown_handler(struct xenbus_watch *watch,
 128                              const char **vec, unsigned int len)
 129 {
 130         char *str;
 131         struct xenbus_transaction xbt;
 132         int err;
 133
 134         if (shutting_down != SHUTDOWN_INVALID)
 135                 return;
 136
 137  again:
 138         err = xenbus_transaction_start(&xbt);
 139         if (err)
 140                 return;
 141
 142         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 143         /* Ignore read errors and empty reads. */
 144         if (XENBUS_IS_ERR_READ(str)) {
 145                 xenbus_transaction_end(xbt, 1);
 146                 return;
 147         }
 148
 149         xenbus_write(xbt, "control", "shutdown", "");
 150
 151         err = xenbus_transaction_end(xbt, 0);
 152         if (err == -EAGAIN) {
 153                 kfree(str);
 154                 goto again;
 155         }
 156
 157         if (strcmp(str, "poweroff") == 0 ||
 158             strcmp(str, "halt") == 0) {
 159                 shutting_down = SHUTDOWN_POWEROFF;
 160                 orderly_poweroff(false);
 161         } else if (strcmp(str, "reboot") == 0) {
 162                 shutting_down = SHUTDOWN_POWEROFF; /* ? */
 163                 ctrl_alt_del();
 164 #ifdef CONFIG_PM_SLEEP
 165         } else if (strcmp(str, "suspend") == 0) {
 166                 do_suspend();
 167 #endif
 168         } else {
 169                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
 170                 shutting_down = SHUTDOWN_INVALID;
 171         }
 172
 173         kfree(str);
 174 }
 175
 176 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
 177                           unsigned int len)
 178 {
 179         char sysrq_key = '\0';
 180         struct xenbus_transaction xbt;
 181         int err;
 182
 183  again:
 184         err = xenbus_transaction_start(&xbt);
 185         if (err)
 186                 return;
 187         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
 188                 printk(KERN_ERR "Unable to read sysrq code in "
 189                        "control/sysrq\n");
 190                 xenbus_transaction_end(xbt, 1);
 191                 return;
 192         }
 193
 194         if (sysrq_key != '\0')
 195                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 196
 197         err = xenbus_transaction_end(xbt, 0);
 198         if (err == -EAGAIN)
 199                 goto again;
 200
 201         if (sysrq_key != '\0')
 202                 handle_sysrq(sysrq_key, NULL);
 203 }
 204
 205 static struct xenbus_watch shutdown_watch = {
 206         .node = "control/shutdown",
 207         .callback = shutdown_handler
 208 };
 209
 210 static struct xenbus_watch sysrq_watch = {
 211         .node = "control/sysrq",
 212         .callback = sysrq_handler
 213 };
 214
 215 static int setup_shutdown_watcher(void)
 216 {
 217         int err;
 218
 219         err = register_xenbus_watch(&shutdown_watch);
 220         if (err) {
 221                 printk(KERN_ERR "Failed to set shutdown watcher\n");
 222                 return err;
 223         }
 224
 225         err = register_xenbus_watch(&sysrq_watch);
 226         if (err) {
 227                 printk(KERN_ERR "Failed to set sysrq watcher\n");
 228                 return err;
 229         }
 230
 231         return 0;
 232 }
 233
 234 static int shutdown_event(struct notifier_block *notifier,
 235                           unsigned long event,
 236                           void *data)
 237 {
 238         setup_shutdown_watcher();
 239         return NOTIFY_DONE;
 240 }
 241
 242 static int __init setup_shutdown_event(void)
 243 {
 244         static struct notifier_block xenstore_notifier = {
 245                 .notifier_call = shutdown_event
 246         };
 247         register_xenstore_notifier(&xenstore_notifier);
 248
 249         return 0;
 250 }
 251
 252 subsys_initcall(setup_shutdown_event);