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