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/slab.h>
   7 #include <linux/reboot.h>
   8 #include <linux/sysrq.h>
   9 #include <linux/stop_machine.h>
  10 #include <linux/freezer.h>
  11 #include <linux/syscore_ops.h>
  12
  13 #include <xen/xen.h>
  14 #include <xen/xenbus.h>
  15 #include <xen/grant_table.h>
  16 #include <xen/events.h>
  17 #include <xen/hvc-console.h>
  18 #include <xen/xen-ops.h>
  19
  20 #include <asm/xen/hypercall.h>
  21 #include <asm/xen/page.h>
  22 #include <asm/xen/hypervisor.h>
  23
  24 enum shutdown_state {
  25         SHUTDOWN_INVALID = -1,
  26         SHUTDOWN_POWEROFF = 0,
  27         SHUTDOWN_SUSPEND = 2,
  28         /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
  29            report a crash, not be instructed to crash!
  30            HALT is the same as POWEROFF, as far as we're concerned.  The tools use
  31            the distinction when we return the reason code to them.  */
  32          SHUTDOWN_HALT = 4,
  33 };
  34
  35 /* Ignore multiple shutdown requests. */
  36 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
  37
  38 struct suspend_info {
  39         int cancelled;
  40         unsigned long arg; /* extra hypercall argument */
  41         void (*pre)(void);
  42         void (*post)(int cancelled);
  43 };
  44
  45 static void xen_hvm_post_suspend(int cancelled)
  46 {
  47         xen_arch_hvm_post_suspend(cancelled);
  48         gnttab_resume();
  49 }
  50
  51 static void xen_pre_suspend(void)
  52 {
  53         xen_mm_pin_all();
  54         gnttab_suspend();
  55         xen_arch_pre_suspend();
  56 }
  57
  58 static void xen_post_suspend(int cancelled)
  59 {
  60         xen_arch_post_suspend(cancelled);
  61         gnttab_resume();
  62         xen_mm_unpin_all();
  63 }
  64
  65 #ifdef CONFIG_HIBERNATE_CALLBACKS
  66 static int xen_suspend(void *data)
  67 {
  68         struct suspend_info *si = data;
  69         int err;
  70
  71         BUG_ON(!irqs_disabled());
  72
  73         err = syscore_suspend();
  74         if (err) {
  75                 printk(KERN_ERR "xen_suspend: system core suspend failed: %d\n",
  76                         err);
  77                 return err;
  78         }
  79
  80         if (si->pre)
  81                 si->pre();
  82
  83         /*
  84          * This hypercall returns 1 if suspend was cancelled
  85          * or the domain was merely checkpointed, and 0 if it
  86          * is resuming in a new domain.
  87          */
  88         si->cancelled = HYPERVISOR_suspend(si->arg);
  89
  90         if (si->post)
  91                 si->post(si->cancelled);
  92
  93         if (!si->cancelled) {
  94                 xen_irq_resume();
  95                 xen_console_resume();
  96                 xen_timer_resume();
  97         }
  98
  99         syscore_resume();
 100
 101         return 0;
 102 }
 103
 104 static void do_suspend(void)
 105 {
 106         int err;
 107         struct suspend_info si;
 108
 109         shutting_down = SHUTDOWN_SUSPEND;
 110
 111 #ifdef CONFIG_PREEMPT
 112         /* If the kernel is preemptible, we need to freeze all the processes
 113            to prevent them from being in the middle of a pagetable update
 114            during suspend. */
 115         err = freeze_processes();
 116         if (err) {
 117                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
 118                 goto out;
 119         }
 120 #endif
 121
 122         err = dpm_suspend_start(PMSG_FREEZE);
 123         if (err) {
 124                 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
 125                 goto out_thaw;
 126         }
 127
 128         printk(KERN_DEBUG "suspending xenstore...\n");
 129         xs_suspend();
 130
 131         err = dpm_suspend_noirq(PMSG_FREEZE);
 132         if (err) {
 133                 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
 134                 goto out_resume;
 135         }
 136
 137         si.cancelled = 1;
 138
 139         if (xen_hvm_domain()) {
 140                 si.arg = 0UL;
 141                 si.pre = NULL;
 142                 si.post = &xen_hvm_post_suspend;
 143         } else {
 144                 si.arg = virt_to_mfn(xen_start_info);
 145                 si.pre = &xen_pre_suspend;
 146                 si.post = &xen_post_suspend;
 147         }
 148
 149         err = stop_machine(xen_suspend, &si, cpumask_of(0));
 150
 151         dpm_resume_noirq(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 152
 153         if (err) {
 154                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
 155                 si.cancelled = 1;
 156         }
 157
 158 out_resume:
 159         if (!si.cancelled) {
 160                 xen_arch_resume();
 161                 xs_resume();
 162         } else
 163                 xs_suspend_cancel();
 164
 165         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 166
 167         /* Make sure timer events get retriggered on all CPUs */
 168         clock_was_set();
 169
 170 out_thaw:
 171 #ifdef CONFIG_PREEMPT
 172         thaw_processes();
 173 out:
 174 #endif
 175         shutting_down = SHUTDOWN_INVALID;
 176 }
 177 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
 178
 179 struct shutdown_handler {
 180         const char *command;
 181         void (*cb)(void);
 182 };
 183
 184 static void do_poweroff(void)
 185 {
 186         shutting_down = SHUTDOWN_POWEROFF;
 187         orderly_poweroff(false);
 188 }
 189
 190 static void do_reboot(void)
 191 {
 192         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 193         ctrl_alt_del();
 194 }
 195
 196 static void shutdown_handler(struct xenbus_watch *watch,
 197                              const char **vec, unsigned int len)
 198 {
 199         char *str;
 200         struct xenbus_transaction xbt;
 201         int err;
 202         static struct shutdown_handler handlers[] = {
 203                 { "poweroff",   do_poweroff },
 204                 { "halt",       do_poweroff },
 205                 { "reboot",     do_reboot   },
 206 #ifdef CONFIG_HIBERNATE_CALLBACKS
 207                 { "suspend",    do_suspend  },
 208 #endif
 209                 {NULL, NULL},
 210         };
 211         static struct shutdown_handler *handler;
 212
 213         if (shutting_down != SHUTDOWN_INVALID)
 214                 return;
 215
 216  again:
 217         err = xenbus_transaction_start(&xbt);
 218         if (err)
 219                 return;
 220
 221         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 222         /* Ignore read errors and empty reads. */
 223         if (XENBUS_IS_ERR_READ(str)) {
 224                 xenbus_transaction_end(xbt, 1);
 225                 return;
 226         }
 227
 228         for (handler = &handlers[0]; handler->command; handler++) {
 229                 if (strcmp(str, handler->command) == 0)
 230                         break;
 231         }
 232
 233         /* Only acknowledge commands which we are prepared to handle. */
 234         if (handler->cb)
 235                 xenbus_write(xbt, "control", "shutdown", "");
 236
 237         err = xenbus_transaction_end(xbt, 0);
 238         if (err == -EAGAIN) {
 239                 kfree(str);
 240                 goto again;
 241         }
 242
 243         if (handler->cb) {
 244                 handler->cb();
 245         } else {
 246                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
 247                 shutting_down = SHUTDOWN_INVALID;
 248         }
 249
 250         kfree(str);
 251 }
 252
 253 #ifdef CONFIG_MAGIC_SYSRQ
 254 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
 255                           unsigned int len)
 256 {
 257         char sysrq_key = '\0';
 258         struct xenbus_transaction xbt;
 259         int err;
 260
 261  again:
 262         err = xenbus_transaction_start(&xbt);
 263         if (err)
 264                 return;
 265         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
 266                 printk(KERN_ERR "Unable to read sysrq code in "
 267                        "control/sysrq\n");
 268                 xenbus_transaction_end(xbt, 1);
 269                 return;
 270         }
 271
 272         if (sysrq_key != '\0')
 273                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 274
 275         err = xenbus_transaction_end(xbt, 0);
 276         if (err == -EAGAIN)
 277                 goto again;
 278
 279         if (sysrq_key != '\0')
 280                 handle_sysrq(sysrq_key);
 281 }
 282
 283 static struct xenbus_watch sysrq_watch = {
 284         .node = "control/sysrq",
 285         .callback = sysrq_handler
 286 };
 287 #endif
 288
 289 static struct xenbus_watch shutdown_watch = {
 290         .node = "control/shutdown",
 291         .callback = shutdown_handler
 292 };
 293
 294 static int setup_shutdown_watcher(void)
 295 {
 296         int err;
 297
 298         err = register_xenbus_watch(&shutdown_watch);
 299         if (err) {
 300                 printk(KERN_ERR "Failed to set shutdown watcher\n");
 301                 return err;
 302         }
 303
 304 #ifdef CONFIG_MAGIC_SYSRQ
 305         err = register_xenbus_watch(&sysrq_watch);
 306         if (err) {
 307                 printk(KERN_ERR "Failed to set sysrq watcher\n");
 308                 return err;
 309         }
 310 #endif
 311
 312         return 0;
 313 }
 314
 315 static int shutdown_event(struct notifier_block *notifier,
 316                           unsigned long event,
 317                           void *data)
 318 {
 319         setup_shutdown_watcher();
 320         return NOTIFY_DONE;
 321 }
 322
 323 int xen_setup_shutdown_event(void)
 324 {
 325         static struct notifier_block xenstore_notifier = {
 326                 .notifier_call = shutdown_event
 327         };
 328
 329         if (!xen_domain())
 330                 return -ENODEV;
 331         register_xenstore_notifier(&xenstore_notifier);
 332
 333         return 0;
 334 }
 335 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 336
 337 subsys_initcall(xen_setup_shutdown_event);