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 = sysdev_suspend(PMSG_FREEZE);
  74         if (!err) {
  75                 err = syscore_suspend();
  76                 if (err)
  77                         sysdev_resume();
  78         }
  79         if (err) {
  80                 printk(KERN_ERR "xen_suspend: system core suspend failed: %d\n",
  81                         err);
  82                 return err;
  83         }
  84
  85         if (si->pre)
  86                 si->pre();
  87
  88         /*
  89          * This hypercall returns 1 if suspend was cancelled
  90          * or the domain was merely checkpointed, and 0 if it
  91          * is resuming in a new domain.
  92          */
  93         si->cancelled = HYPERVISOR_suspend(si->arg);
  94
  95         if (si->post)
  96                 si->post(si->cancelled);
  97
  98         if (!si->cancelled) {
  99                 xen_irq_resume();
 100                 xen_console_resume();
 101                 xen_timer_resume();
 102         }
 103
 104         syscore_resume();
 105         sysdev_resume();
 106
 107         return 0;
 108 }
 109
 110 static void do_suspend(void)
 111 {
 112         int err;
 113         struct suspend_info si;
 114
 115         shutting_down = SHUTDOWN_SUSPEND;
 116
 117 #ifdef CONFIG_PREEMPT
 118         /* If the kernel is preemptible, we need to freeze all the processes
 119            to prevent them from being in the middle of a pagetable update
 120            during suspend. */
 121         err = freeze_processes();
 122         if (err) {
 123                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
 124                 goto out;
 125         }
 126 #endif
 127
 128         err = dpm_suspend_start(PMSG_FREEZE);
 129         if (err) {
 130                 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
 131                 goto out_thaw;
 132         }
 133
 134         printk(KERN_DEBUG "suspending xenstore...\n");
 135         xs_suspend();
 136
 137         err = dpm_suspend_noirq(PMSG_FREEZE);
 138         if (err) {
 139                 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
 140                 goto out_resume;
 141         }
 142
 143         si.cancelled = 1;
 144
 145         if (xen_hvm_domain()) {
 146                 si.arg = 0UL;
 147                 si.pre = NULL;
 148                 si.post = &xen_hvm_post_suspend;
 149         } else {
 150                 si.arg = virt_to_mfn(xen_start_info);
 151                 si.pre = &xen_pre_suspend;
 152                 si.post = &xen_post_suspend;
 153         }
 154
 155         err = stop_machine(xen_suspend, &si, cpumask_of(0));
 156
 157         dpm_resume_noirq(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 158
 159         if (err) {
 160                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
 161                 si.cancelled = 1;
 162         }
 163
 164 out_resume:
 165         if (!si.cancelled) {
 166                 xen_arch_resume();
 167                 xs_resume();
 168         } else
 169                 xs_suspend_cancel();
 170
 171         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 172
 173         /* Make sure timer events get retriggered on all CPUs */
 174         clock_was_set();
 175
 176 out_thaw:
 177 #ifdef CONFIG_PREEMPT
 178         thaw_processes();
 179 out:
 180 #endif
 181         shutting_down = SHUTDOWN_INVALID;
 182 }
 183 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
 184
 185 struct shutdown_handler {
 186         const char *command;
 187         void (*cb)(void);
 188 };
 189
 190 static void do_poweroff(void)
 191 {
 192         shutting_down = SHUTDOWN_POWEROFF;
 193         orderly_poweroff(false);
 194 }
 195
 196 static void do_reboot(void)
 197 {
 198         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 199         ctrl_alt_del();
 200 }
 201
 202 static void shutdown_handler(struct xenbus_watch *watch,
 203                              const char **vec, unsigned int len)
 204 {
 205         char *str;
 206         struct xenbus_transaction xbt;
 207         int err;
 208         static struct shutdown_handler handlers[] = {
 209                 { "poweroff",   do_poweroff },
 210                 { "halt",       do_poweroff },
 211                 { "reboot",     do_reboot   },
 212 #ifdef CONFIG_HIBERNATE_CALLBACKS
 213                 { "suspend",    do_suspend  },
 214 #endif
 215                 {NULL, NULL},
 216         };
 217         static struct shutdown_handler *handler;
 218
 219         if (shutting_down != SHUTDOWN_INVALID)
 220                 return;
 221
 222  again:
 223         err = xenbus_transaction_start(&xbt);
 224         if (err)
 225                 return;
 226
 227         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 228         /* Ignore read errors and empty reads. */
 229         if (XENBUS_IS_ERR_READ(str)) {
 230                 xenbus_transaction_end(xbt, 1);
 231                 return;
 232         }
 233
 234         for (handler = &handlers[0]; handler->command; handler++) {
 235                 if (strcmp(str, handler->command) == 0)
 236                         break;
 237         }
 238
 239         /* Only acknowledge commands which we are prepared to handle. */
 240         if (handler->cb)
 241                 xenbus_write(xbt, "control", "shutdown", "");
 242
 243         err = xenbus_transaction_end(xbt, 0);
 244         if (err == -EAGAIN) {
 245                 kfree(str);
 246                 goto again;
 247         }
 248
 249         if (handler->cb) {
 250                 handler->cb();
 251         } else {
 252                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
 253                 shutting_down = SHUTDOWN_INVALID;
 254         }
 255
 256         kfree(str);
 257 }
 258
 259 #ifdef CONFIG_MAGIC_SYSRQ
 260 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
 261                           unsigned int len)
 262 {
 263         char sysrq_key = '\0';
 264         struct xenbus_transaction xbt;
 265         int err;
 266
 267  again:
 268         err = xenbus_transaction_start(&xbt);
 269         if (err)
 270                 return;
 271         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
 272                 printk(KERN_ERR "Unable to read sysrq code in "
 273                        "control/sysrq\n");
 274                 xenbus_transaction_end(xbt, 1);
 275                 return;
 276         }
 277
 278         if (sysrq_key != '\0')
 279                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 280
 281         err = xenbus_transaction_end(xbt, 0);
 282         if (err == -EAGAIN)
 283                 goto again;
 284
 285         if (sysrq_key != '\0')
 286                 handle_sysrq(sysrq_key);
 287 }
 288
 289 static struct xenbus_watch sysrq_watch = {
 290         .node = "control/sysrq",
 291         .callback = sysrq_handler
 292 };
 293 #endif
 294
 295 static struct xenbus_watch shutdown_watch = {
 296         .node = "control/shutdown",
 297         .callback = shutdown_handler
 298 };
 299
 300 static int setup_shutdown_watcher(void)
 301 {
 302         int err;
 303
 304         err = register_xenbus_watch(&shutdown_watch);
 305         if (err) {
 306                 printk(KERN_ERR "Failed to set shutdown watcher\n");
 307                 return err;
 308         }
 309
 310 #ifdef CONFIG_MAGIC_SYSRQ
 311         err = register_xenbus_watch(&sysrq_watch);
 312         if (err) {
 313                 printk(KERN_ERR "Failed to set sysrq watcher\n");
 314                 return err;
 315         }
 316 #endif
 317
 318         return 0;
 319 }
 320
 321 static int shutdown_event(struct notifier_block *notifier,
 322                           unsigned long event,
 323                           void *data)
 324 {
 325         setup_shutdown_watcher();
 326         return NOTIFY_DONE;
 327 }
 328
 329 int xen_setup_shutdown_event(void)
 330 {
 331         static struct notifier_block xenstore_notifier = {
 332                 .notifier_call = shutdown_event
 333         };
 334
 335         if (!xen_domain())
 336                 return -ENODEV;
 337         register_xenstore_notifier(&xenstore_notifier);
 338
 339         return 0;
 340 }
 341 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 342
 343 subsys_initcall(xen_setup_shutdown_event);