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         case SYSTEM_SCHEDULING:
 194                 orderly_poweroff(true);
 195                 break;
 196         case SYSTEM_RUNNING:
 197                 orderly_poweroff(false);
 198                 break;
 199         default:
 200                 /* Don't do it when we are halting/rebooting. */
 201                 pr_info("Ignoring Xen toolstack shutdown.\n");
 202                 break;
 203         }
 204 }
 205
 206 static void do_reboot(void)
 207 {
 208         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 209         ctrl_alt_del();
 210 }
 211
 212 static struct shutdown_handler shutdown_handlers[] = {
 213         { "poweroff",   true,   do_poweroff },
 214         { "halt",       false,  do_poweroff },
 215         { "reboot",     true,   do_reboot   },
 216 #ifdef CONFIG_HIBERNATE_CALLBACKS
 217         { "suspend",    true,   do_suspend  },
 218 #endif
 219 };
 220
 221 static void shutdown_handler(struct xenbus_watch *watch,
 222                              const char *path, const char *token)
 223 {
 224         char *str;
 225         struct xenbus_transaction xbt;
 226         int err;
 227         int idx;
 228
 229         if (shutting_down != SHUTDOWN_INVALID)
 230                 return;
 231
 232  again:
 233         err = xenbus_transaction_start(&xbt);
 234         if (err)
 235                 return;
 236
 237         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 238         /* Ignore read errors and empty reads. */
 239         if (XENBUS_IS_ERR_READ(str)) {
 240                 xenbus_transaction_end(xbt, 1);
 241                 return;
 242         }
 243
 244         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 245                 if (strcmp(str, shutdown_handlers[idx].command) == 0)
 246                         break;
 247         }
 248
 249         /* Only acknowledge commands which we are prepared to handle. */
 250         if (idx < ARRAY_SIZE(shutdown_handlers))
 251                 xenbus_write(xbt, "control", "shutdown", "");
 252
 253         err = xenbus_transaction_end(xbt, 0);
 254         if (err == -EAGAIN) {
 255                 kfree(str);
 256                 goto again;
 257         }
 258
 259         if (idx < ARRAY_SIZE(shutdown_handlers)) {
 260                 shutdown_handlers[idx].cb();
 261         } else {
 262                 pr_info("Ignoring shutdown request: %s\n", str);
 263                 shutting_down = SHUTDOWN_INVALID;
 264         }
 265
 266         kfree(str);
 267 }
 268
 269 #ifdef CONFIG_MAGIC_SYSRQ
 270 static void sysrq_handler(struct xenbus_watch *watch, const char *path,
 271                           const char *token)
 272 {
 273         char sysrq_key = '\0';
 274         struct xenbus_transaction xbt;
 275         int err;
 276
 277  again:
 278         err = xenbus_transaction_start(&xbt);
 279         if (err)
 280                 return;
 281         err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key);
 282         if (err < 0) {
 283                 /*
 284                  * The Xenstore watch fires directly after registering it and
 285                  * after a suspend/resume cycle. So ENOENT is no error but
 286                  * might happen in those cases. ERANGE is observed when we get
 287                  * an empty value (''), this happens when we acknowledge the
 288                  * request by writing '\0' below.
 289                  */
 290                 if (err != -ENOENT && err != -ERANGE)
 291                         pr_err("Error %d reading sysrq code in control/sysrq\n",
 292                                err);
 293                 xenbus_transaction_end(xbt, 1);
 294                 return;
 295         }
 296
 297         if (sysrq_key != '\0') {
 298                 err = xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 299                 if (err) {
 300                         pr_err("%s: Error %d writing sysrq in control/sysrq\n",
 301                                __func__, err);
 302                         xenbus_transaction_end(xbt, 1);
 303                         return;
 304                 }
 305         }
 306
 307         err = xenbus_transaction_end(xbt, 0);
 308         if (err == -EAGAIN)
 309                 goto again;
 310
 311         if (sysrq_key != '\0')
 312                 handle_sysrq(sysrq_key);
 313 }
 314
 315 static struct xenbus_watch sysrq_watch = {
 316         .node = "control/sysrq",
 317         .callback = sysrq_handler
 318 };
 319 #endif
 320
 321 static struct xenbus_watch shutdown_watch = {
 322         .node = "control/shutdown",
 323         .callback = shutdown_handler
 324 };
 325
 326 static struct notifier_block xen_reboot_nb = {
 327         .notifier_call = poweroff_nb,
 328 };
 329
 330 static int setup_shutdown_watcher(void)
 331 {
 332         int err;
 333         int idx;
 334 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
 335         char node[FEATURE_PATH_SIZE];
 336
 337         err = register_xenbus_watch(&shutdown_watch);
 338         if (err) {
 339                 pr_err("Failed to set shutdown watcher\n");
 340                 return err;
 341         }
 342
 343
 344 #ifdef CONFIG_MAGIC_SYSRQ
 345         err = register_xenbus_watch(&sysrq_watch);
 346         if (err) {
 347                 pr_err("Failed to set sysrq watcher\n");
 348                 return err;
 349         }
 350 #endif
 351
 352         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 353                 if (!shutdown_handlers[idx].flag)
 354                         continue;
 355                 snprintf(node, FEATURE_PATH_SIZE, "feature-%s",
 356                          shutdown_handlers[idx].command);
 357                 err = xenbus_printf(XBT_NIL, "control", node, "%u", 1);
 358                 if (err) {
 359                         pr_err("%s: Error %d writing %s\n", __func__,
 360                                 err, node);
 361                         return err;
 362                 }
 363         }
 364
 365         return 0;
 366 }
 367
 368 static int shutdown_event(struct notifier_block *notifier,
 369                           unsigned long event,
 370                           void *data)
 371 {
 372         setup_shutdown_watcher();
 373         return NOTIFY_DONE;
 374 }
 375
 376 int xen_setup_shutdown_event(void)
 377 {
 378         static struct notifier_block xenstore_notifier = {
 379                 .notifier_call = shutdown_event
 380         };
 381
 382         if (!xen_domain())
 383                 return -ENODEV;
 384         register_xenstore_notifier(&xenstore_notifier);
 385         register_reboot_notifier(&xen_reboot_nb);
 386
 387         return 0;
 388 }
 389 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 390
 391 subsys_initcall(xen_setup_shutdown_event);