drivers/xen/manage.c

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