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 #ifdef CONFIG_HIBERNATE_CALLBACKS
  50 static void xen_hvm_post_suspend(int cancelled)
  51 {
  52         xen_arch_hvm_post_suspend(cancelled);
  53         gnttab_resume();
  54 }
  55
  56 static void xen_pre_suspend(void)
  57 {
  58         xen_mm_pin_all();
  59         gnttab_suspend();
  60         xen_arch_pre_suspend();
  61 }
  62
  63 static void xen_post_suspend(int cancelled)
  64 {
  65         xen_arch_post_suspend(cancelled);
  66         gnttab_resume();
  67         xen_mm_unpin_all();
  68 }
  69
  70 static int xen_suspend(void *data)
  71 {
  72         struct suspend_info *si = data;
  73         int err;
  74
  75         BUG_ON(!irqs_disabled());
  76
  77         err = syscore_suspend();
  78         if (err) {
  79                 pr_err("%s: system core suspend failed: %d\n", __func__, err);
  80                 return err;
  81         }
  82
  83         if (si->pre)
  84                 si->pre();
  85
  86         /*
  87          * This hypercall returns 1 if suspend was cancelled
  88          * or the domain was merely checkpointed, and 0 if it
  89          * is resuming in a new domain.
  90          */
  91         si->cancelled = HYPERVISOR_suspend(si->arg);
  92
  93         if (si->post)
  94                 si->post(si->cancelled);
  95
  96         if (!si->cancelled) {
  97                 xen_irq_resume();
  98                 xen_console_resume();
  99                 xen_timer_resume();
 100         }
 101
 102         syscore_resume();
 103
 104         return 0;
 105 }
 106
 107 static void do_suspend(void)
 108 {
 109         int err;
 110         struct suspend_info si;
 111
 112         shutting_down = SHUTDOWN_SUSPEND;
 113
 114 #ifdef CONFIG_PREEMPT
 115         /* If the kernel is preemptible, we need to freeze all the processes
 116            to prevent them from being in the middle of a pagetable update
 117            during suspend. */
 118         err = freeze_processes();
 119         if (err) {
 120                 pr_err("%s: freeze failed %d\n", __func__, err);
 121                 goto out;
 122         }
 123 #endif
 124
 125         err = dpm_suspend_start(PMSG_FREEZE);
 126         if (err) {
 127                 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
 128                 goto out_thaw;
 129         }
 130
 131         printk(KERN_DEBUG "suspending xenstore...\n");
 132         xs_suspend();
 133
 134         err = dpm_suspend_end(PMSG_FREEZE);
 135         if (err) {
 136                 pr_err("dpm_suspend_end failed: %d\n", err);
 137                 si.cancelled = 0;
 138                 goto out_resume;
 139         }
 140
 141         si.cancelled = 1;
 142
 143         if (xen_hvm_domain()) {
 144                 si.arg = 0UL;
 145                 si.pre = NULL;
 146                 si.post = &xen_hvm_post_suspend;
 147         } else {
 148                 si.arg = virt_to_mfn(xen_start_info);
 149                 si.pre = &xen_pre_suspend;
 150                 si.post = &xen_post_suspend;
 151         }
 152
 153         err = stop_machine(xen_suspend, &si, cpumask_of(0));
 154
 155         dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 156
 157         if (err) {
 158                 pr_err("failed to start xen_suspend: %d\n", err);
 159                 si.cancelled = 1;
 160         }
 161
 162 out_resume:
 163         if (!si.cancelled) {
 164                 xen_arch_resume();
 165                 xs_resume();
 166         } else
 167                 xs_suspend_cancel();
 168
 169         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 170
 171 out_thaw:
 172 #ifdef CONFIG_PREEMPT
 173         thaw_processes();
 174 out:
 175 #endif
 176         shutting_down = SHUTDOWN_INVALID;
 177 }
 178 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
 179
 180 struct shutdown_handler {
 181         const char *command;
 182         void (*cb)(void);
 183 };
 184
 185 static void do_poweroff(void)
 186 {
 187         shutting_down = SHUTDOWN_POWEROFF;
 188         orderly_poweroff(false);
 189 }
 190
 191 static void do_reboot(void)
 192 {
 193         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 194         ctrl_alt_del();
 195 }
 196
 197 static void shutdown_handler(struct xenbus_watch *watch,
 198                              const char **vec, unsigned int len)
 199 {
 200         char *str;
 201         struct xenbus_transaction xbt;
 202         int err;
 203         static struct shutdown_handler handlers[] = {
 204                 { "poweroff",   do_poweroff },
 205                 { "halt",       do_poweroff },
 206                 { "reboot",     do_reboot   },
 207 #ifdef CONFIG_HIBERNATE_CALLBACKS
 208                 { "suspend",    do_suspend  },
 209 #endif
 210                 {NULL, NULL},
 211         };
 212         static struct shutdown_handler *handler;
 213
 214         if (shutting_down != SHUTDOWN_INVALID)
 215                 return;
 216
 217  again:
 218         err = xenbus_transaction_start(&xbt);
 219         if (err)
 220                 return;
 221
 222         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 223         /* Ignore read errors and empty reads. */
 224         if (XENBUS_IS_ERR_READ(str)) {
 225                 xenbus_transaction_end(xbt, 1);
 226                 return;
 227         }
 228
 229         for (handler = &handlers[0]; handler->command; handler++) {
 230                 if (strcmp(str, handler->command) == 0)
 231                         break;
 232         }
 233
 234         /* Only acknowledge commands which we are prepared to handle. */
 235         if (handler->cb)
 236                 xenbus_write(xbt, "control", "shutdown", "");
 237
 238         err = xenbus_transaction_end(xbt, 0);
 239         if (err == -EAGAIN) {
 240                 kfree(str);
 241                 goto again;
 242         }
 243
 244         if (handler->cb) {
 245                 handler->cb();
 246         } else {
 247                 pr_info("Ignoring shutdown request: %s\n", str);
 248                 shutting_down = SHUTDOWN_INVALID;
 249         }
 250
 251         kfree(str);
 252 }
 253
 254 #ifdef CONFIG_MAGIC_SYSRQ
 255 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
 256                           unsigned int len)
 257 {
 258         char sysrq_key = '\0';
 259         struct xenbus_transaction xbt;
 260         int err;
 261
 262  again:
 263         err = xenbus_transaction_start(&xbt);
 264         if (err)
 265                 return;
 266         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
 267                 pr_err("Unable to read sysrq code in 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                 pr_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                 pr_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);