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