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/page.h>
  23 #include <xen/xen-ops.h>
  24
  25 #include <asm/xen/hypercall.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_gfn(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         err = freeze_processes();
 107         if (err) {
 108                 pr_err("%s: freeze processes failed %d\n", __func__, err);
 109                 goto out;
 110         }
 111
 112         err = freeze_kernel_threads();
 113         if (err) {
 114                 pr_err("%s: freeze kernel threads failed %d\n", __func__, err);
 115                 goto out_thaw;
 116         }
 117
 118         err = dpm_suspend_start(PMSG_FREEZE);
 119         if (err) {
 120                 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
 121                 goto out_thaw;
 122         }
 123
 124         printk(KERN_DEBUG "suspending xenstore...\n");
 125         xs_suspend();
 126
 127         err = dpm_suspend_end(PMSG_FREEZE);
 128         if (err) {
 129                 pr_err("dpm_suspend_end failed: %d\n", err);
 130                 si.cancelled = 0;
 131                 goto out_resume;
 132         }
 133
 134         xen_arch_suspend();
 135
 136         si.cancelled = 1;
 137
 138         err = stop_machine(xen_suspend, &si, cpumask_of(0));
 139
 140         /* Resume console as early as possible. */
 141         if (!si.cancelled)
 142                 xen_console_resume();
 143
 144         raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);
 145
 146         dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 147
 148         if (err) {
 149                 pr_err("failed to start xen_suspend: %d\n", err);
 150                 si.cancelled = 1;
 151         }
 152
 153         xen_arch_resume();
 154
 155 out_resume:
 156         if (!si.cancelled)
 157                 xs_resume();
 158         else
 159                 xs_suspend_cancel();
 160
 161         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 162
 163 out_thaw:
 164         thaw_processes();
 165 out:
 166         shutting_down = SHUTDOWN_INVALID;
 167 }
 168 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
 169
 170 struct shutdown_handler {
 171         const char *command;
 172         void (*cb)(void);
 173 };
 174
 175 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused)
 176 {
 177         switch (code) {
 178         case SYS_DOWN:
 179         case SYS_HALT:
 180         case SYS_POWER_OFF:
 181                 shutting_down = SHUTDOWN_POWEROFF;
 182         default:
 183                 break;
 184         }
 185         return NOTIFY_DONE;
 186 }
 187 static void do_poweroff(void)
 188 {
 189         switch (system_state) {
 190         case SYSTEM_BOOTING:
 191                 orderly_poweroff(true);
 192                 break;
 193         case SYSTEM_RUNNING:
 194                 orderly_poweroff(false);
 195                 break;
 196         default:
 197                 /* Don't do it when we are halting/rebooting. */
 198                 pr_info("Ignoring Xen toolstack shutdown.\n");
 199                 break;
 200         }
 201 }
 202
 203 static void do_reboot(void)
 204 {
 205         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 206         ctrl_alt_del();
 207 }
 208
 209 static void shutdown_handler(struct xenbus_watch *watch,
 210                              const char **vec, unsigned int len)
 211 {
 212         char *str;
 213         struct xenbus_transaction xbt;
 214         int err;
 215         static struct shutdown_handler handlers[] = {
 216                 { "poweroff",   do_poweroff },
 217                 { "halt",       do_poweroff },
 218                 { "reboot",     do_reboot   },
 219 #ifdef CONFIG_HIBERNATE_CALLBACKS
 220                 { "suspend",    do_suspend  },
 221 #endif
 222                 {NULL, NULL},
 223         };
 224         static struct shutdown_handler *handler;
 225
 226         if (shutting_down != SHUTDOWN_INVALID)
 227                 return;
 228
 229  again:
 230         err = xenbus_transaction_start(&xbt);
 231         if (err)
 232                 return;
 233
 234         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 235         /* Ignore read errors and empty reads. */
 236         if (XENBUS_IS_ERR_READ(str)) {
 237                 xenbus_transaction_end(xbt, 1);
 238                 return;
 239         }
 240
 241         for (handler = &handlers[0]; handler->command; handler++) {
 242                 if (strcmp(str, handler->command) == 0)
 243                         break;
 244         }
 245
 246         /* Only acknowledge commands which we are prepared to handle. */
 247         if (handler->cb)
 248                 xenbus_write(xbt, "control", "shutdown", "");
 249
 250         err = xenbus_transaction_end(xbt, 0);
 251         if (err == -EAGAIN) {
 252                 kfree(str);
 253                 goto again;
 254         }
 255
 256         if (handler->cb) {
 257                 handler->cb();
 258         } else {
 259                 pr_info("Ignoring shutdown request: %s\n", str);
 260                 shutting_down = SHUTDOWN_INVALID;
 261         }
 262
 263         kfree(str);
 264 }
 265
 266 #ifdef CONFIG_MAGIC_SYSRQ
 267 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
 268                           unsigned int len)
 269 {
 270         char sysrq_key = '\0';
 271         struct xenbus_transaction xbt;
 272         int err;
 273
 274  again:
 275         err = xenbus_transaction_start(&xbt);
 276         if (err)
 277                 return;
 278         err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key);
 279         if (err < 0) {
 280                 /*
 281                  * The Xenstore watch fires directly after registering it and
 282                  * after a suspend/resume cycle. So ENOENT is no error but
 283                  * might happen in those cases. ERANGE is observed when we get
 284                  * an empty value (''), this happens when we acknowledge the
 285                  * request by writing '\0' below.
 286                  */
 287                 if (err != -ENOENT && err != -ERANGE)
 288                         pr_err("Error %d reading sysrq code in control/sysrq\n",
 289                                err);
 290                 xenbus_transaction_end(xbt, 1);
 291                 return;
 292         }
 293
 294         if (sysrq_key != '\0')
 295                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 296
 297         err = xenbus_transaction_end(xbt, 0);
 298         if (err == -EAGAIN)
 299                 goto again;
 300
 301         if (sysrq_key != '\0')
 302                 handle_sysrq(sysrq_key);
 303 }
 304
 305 static struct xenbus_watch sysrq_watch = {
 306         .node = "control/sysrq",
 307         .callback = sysrq_handler
 308 };
 309 #endif
 310
 311 static struct xenbus_watch shutdown_watch = {
 312         .node = "control/shutdown",
 313         .callback = shutdown_handler
 314 };
 315
 316 static struct notifier_block xen_reboot_nb = {
 317         .notifier_call = poweroff_nb,
 318 };
 319
 320 static int setup_shutdown_watcher(void)
 321 {
 322         int err;
 323
 324         err = register_xenbus_watch(&shutdown_watch);
 325         if (err) {
 326                 pr_err("Failed to set shutdown watcher\n");
 327                 return err;
 328         }
 329
 330
 331 #ifdef CONFIG_MAGIC_SYSRQ
 332         err = register_xenbus_watch(&sysrq_watch);
 333         if (err) {
 334                 pr_err("Failed to set sysrq watcher\n");
 335                 return err;
 336         }
 337 #endif
 338
 339         return 0;
 340 }
 341
 342 static int shutdown_event(struct notifier_block *notifier,
 343                           unsigned long event,
 344                           void *data)
 345 {
 346         setup_shutdown_watcher();
 347         return NOTIFY_DONE;
 348 }
 349
 350 int xen_setup_shutdown_event(void)
 351 {
 352         static struct notifier_block xenstore_notifier = {
 353                 .notifier_call = shutdown_event
 354         };
 355
 356         if (!xen_domain())
 357                 return -ENODEV;
 358         register_xenstore_notifier(&xenstore_notifier);
 359         register_reboot_notifier(&xen_reboot_nb);
 360
 361         return 0;
 362 }
 363 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 364
 365 subsys_initcall(xen_setup_shutdown_event);