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