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 #define SHUTDOWN_CMD_SIZE 11
 172         const char command[SHUTDOWN_CMD_SIZE];
 173         bool flag;
 174         void (*cb)(void);
 175 };
 176
 177 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused)
 178 {
 179         switch (code) {
 180         case SYS_DOWN:
 181         case SYS_HALT:
 182         case SYS_POWER_OFF:
 183                 shutting_down = SHUTDOWN_POWEROFF;
 184         default:
 185                 break;
 186         }
 187         return NOTIFY_DONE;
 188 }
 189 static void do_poweroff(void)
 190 {
 191         switch (system_state) {
 192         case SYSTEM_BOOTING:
 193                 orderly_poweroff(true);
 194                 break;
 195         case SYSTEM_RUNNING:
 196                 orderly_poweroff(false);
 197                 break;
 198         default:
 199                 /* Don't do it when we are halting/rebooting. */
 200                 pr_info("Ignoring Xen toolstack shutdown.\n");
 201                 break;
 202         }
 203 }
 204
 205 static void do_reboot(void)
 206 {
 207         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 208         ctrl_alt_del();
 209 }
 210
 211 static struct shutdown_handler shutdown_handlers[] = {
 212         { "poweroff",   true,   do_poweroff },
 213         { "halt",       false,  do_poweroff },
 214         { "reboot",     true,   do_reboot   },
 215 #ifdef CONFIG_HIBERNATE_CALLBACKS
 216         { "suspend",    true,   do_suspend  },
 217 #endif
 218 };
 219
 220 static void shutdown_handler(struct xenbus_watch *watch,
 221                              const char *path, const char *token)
 222 {
 223         char *str;
 224         struct xenbus_transaction xbt;
 225         int err;
 226         int idx;
 227
 228         if (shutting_down != SHUTDOWN_INVALID)
 229                 return;
 230
 231  again:
 232         err = xenbus_transaction_start(&xbt);
 233         if (err)
 234                 return;
 235
 236         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 237         /* Ignore read errors and empty reads. */
 238         if (XENBUS_IS_ERR_READ(str)) {
 239                 xenbus_transaction_end(xbt, 1);
 240                 return;
 241         }
 242
 243         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 244                 if (strcmp(str, shutdown_handlers[idx].command) == 0)
 245                         break;
 246         }
 247
 248         /* Only acknowledge commands which we are prepared to handle. */
 249         if (idx < ARRAY_SIZE(shutdown_handlers))
 250                 xenbus_write(xbt, "control", "shutdown", "");
 251
 252         err = xenbus_transaction_end(xbt, 0);
 253         if (err == -EAGAIN) {
 254                 kfree(str);
 255                 goto again;
 256         }
 257
 258         if (idx < ARRAY_SIZE(shutdown_handlers)) {
 259                 shutdown_handlers[idx].cb();
 260         } else {
 261                 pr_info("Ignoring shutdown request: %s\n", str);
 262                 shutting_down = SHUTDOWN_INVALID;
 263         }
 264
 265         kfree(str);
 266 }
 267
 268 #ifdef CONFIG_MAGIC_SYSRQ
 269 static void sysrq_handler(struct xenbus_watch *watch, const char *path,
 270                           const char *token)
 271 {
 272         char sysrq_key = '\0';
 273         struct xenbus_transaction xbt;
 274         int err;
 275
 276  again:
 277         err = xenbus_transaction_start(&xbt);
 278         if (err)
 279                 return;
 280         if (xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key) < 0) {
 281                 pr_err("Unable to read sysrq code in control/sysrq\n");
 282                 xenbus_transaction_end(xbt, 1);
 283                 return;
 284         }
 285
 286         if (sysrq_key != '\0')
 287                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 288
 289         err = xenbus_transaction_end(xbt, 0);
 290         if (err == -EAGAIN)
 291                 goto again;
 292
 293         if (sysrq_key != '\0')
 294                 handle_sysrq(sysrq_key);
 295 }
 296
 297 static struct xenbus_watch sysrq_watch = {
 298         .node = "control/sysrq",
 299         .callback = sysrq_handler
 300 };
 301 #endif
 302
 303 static struct xenbus_watch shutdown_watch = {
 304         .node = "control/shutdown",
 305         .callback = shutdown_handler
 306 };
 307
 308 static struct notifier_block xen_reboot_nb = {
 309         .notifier_call = poweroff_nb,
 310 };
 311
 312 static int setup_shutdown_watcher(void)
 313 {
 314         int err;
 315         int idx;
 316 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
 317         char node[FEATURE_PATH_SIZE];
 318
 319         err = register_xenbus_watch(&shutdown_watch);
 320         if (err) {
 321                 pr_err("Failed to set shutdown watcher\n");
 322                 return err;
 323         }
 324
 325
 326 #ifdef CONFIG_MAGIC_SYSRQ
 327         err = register_xenbus_watch(&sysrq_watch);
 328         if (err) {
 329                 pr_err("Failed to set sysrq watcher\n");
 330                 return err;
 331         }
 332 #endif
 333
 334         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 335                 if (!shutdown_handlers[idx].flag)
 336                         continue;
 337                 snprintf(node, FEATURE_PATH_SIZE, "feature-%s",
 338                          shutdown_handlers[idx].command);
 339                 xenbus_printf(XBT_NIL, "control", node, "%u", 1);
 340         }
 341
 342         return 0;
 343 }
 344
 345 static int shutdown_event(struct notifier_block *notifier,
 346                           unsigned long event,
 347                           void *data)
 348 {
 349         setup_shutdown_watcher();
 350         return NOTIFY_DONE;
 351 }
 352
 353 int xen_setup_shutdown_event(void)
 354 {
 355         static struct notifier_block xenstore_notifier = {
 356                 .notifier_call = shutdown_event
 357         };
 358
 359         if (!xen_domain())
 360                 return -ENODEV;
 361         register_xenstore_notifier(&xenstore_notifier);
 362         register_reboot_notifier(&xen_reboot_nb);
 363
 364         return 0;
 365 }
 366 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 367
 368 subsys_initcall(xen_setup_shutdown_event);