drivers/xen/manage.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
xen_resume_notifier_register
xen_resume_notifier_unregister
xen_suspend
do_suspend
poweroff_nb
do_poweroff
do_reboot
shutdown_handler
sysrq_handler
setup_shutdown_watcher
shutdown_event
xen_setup_shutdown_event
   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Handle extern requests for shutdown, reboot and sysrq
   4  */
   5 
   6 #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
   7 
   8 #include <linux/kernel.h>
   9 #include <linux/err.h>
  10 #include <linux/slab.h>
  11 #include <linux/reboot.h>
  12 #include <linux/sysrq.h>
  13 #include <linux/stop_machine.h>
  14 #include <linux/freezer.h>
  15 #include <linux/syscore_ops.h>
  16 #include <linux/export.h>
  17 
  18 #include <xen/xen.h>
  19 #include <xen/xenbus.h>
  20 #include <xen/grant_table.h>
  21 #include <xen/events.h>
  22 #include <xen/hvc-console.h>
  23 #include <xen/page.h>
  24 #include <xen/xen-ops.h>
  25 
  26 #include <asm/xen/hypercall.h>
  27 #include <asm/xen/hypervisor.h>
  28 
  29 enum shutdown_state {
  30         SHUTDOWN_INVALID = -1,
  31         SHUTDOWN_POWEROFF = 0,
  32         SHUTDOWN_SUSPEND = 2,
  33         /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
  34            report a crash, not be instructed to crash!
  35            HALT is the same as POWEROFF, as far as we're concerned.  The tools use
  36            the distinction when we return the reason code to them.  */
  37          SHUTDOWN_HALT = 4,
  38 };
  39 
  40 /* Ignore multiple shutdown requests. */
  41 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
  42 
  43 struct suspend_info {
  44         int cancelled;
  45 };
  46 
  47 static RAW_NOTIFIER_HEAD(xen_resume_notifier);
  48 
  49 void xen_resume_notifier_register(struct notifier_block *nb)
  50 {
  51         raw_notifier_chain_register(&xen_resume_notifier, nb);
  52 }
  53 EXPORT_SYMBOL_GPL(xen_resume_notifier_register);
  54 
  55 void xen_resume_notifier_unregister(struct notifier_block *nb)
  56 {
  57         raw_notifier_chain_unregister(&xen_resume_notifier, nb);
  58 }
  59 EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister);
  60 
  61 #ifdef CONFIG_HIBERNATE_CALLBACKS
  62 static int xen_suspend(void *data)
  63 {
  64         struct suspend_info *si = data;
  65         int err;
  66 
  67         BUG_ON(!irqs_disabled());
  68 
  69         err = syscore_suspend();
  70         if (err) {
  71                 pr_err("%s: system core suspend failed: %d\n", __func__, err);
  72                 return err;
  73         }
  74 
  75         gnttab_suspend();
  76         xen_manage_runstate_time(-1);
  77         xen_arch_pre_suspend();
  78 
  79         si->cancelled = HYPERVISOR_suspend(xen_pv_domain()
  80                                            ? virt_to_gfn(xen_start_info)
  81                                            : 0);
  82 
  83         xen_arch_post_suspend(si->cancelled);
  84         xen_manage_runstate_time(si->cancelled ? 1 : 0);
  85         gnttab_resume();
  86 
  87         if (!si->cancelled) {
  88                 xen_irq_resume();
  89                 xen_timer_resume();
  90         }
  91 
  92         syscore_resume();
  93 
  94         return 0;
  95 }
  96 
  97 static void do_suspend(void)
  98 {
  99         int err;
 100         struct suspend_info si;
 101 
 102         shutting_down = SHUTDOWN_SUSPEND;
 103 
 104         err = freeze_processes();
 105         if (err) {
 106                 pr_err("%s: freeze processes failed %d\n", __func__, err);
 107                 goto out;
 108         }
 109 
 110         err = freeze_kernel_threads();
 111         if (err) {
 112                 pr_err("%s: freeze kernel threads failed %d\n", __func__, err);
 113                 goto out_thaw;
 114         }
 115 
 116         err = dpm_suspend_start(PMSG_FREEZE);
 117         if (err) {
 118                 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
 119                 goto out_thaw;
 120         }
 121 
 122         printk(KERN_DEBUG "suspending xenstore...\n");
 123         xs_suspend();
 124 
 125         err = dpm_suspend_end(PMSG_FREEZE);
 126         if (err) {
 127                 pr_err("dpm_suspend_end failed: %d\n", err);
 128                 si.cancelled = 0;
 129                 goto out_resume;
 130         }
 131 
 132         xen_arch_suspend();
 133 
 134         si.cancelled = 1;
 135 
 136         err = stop_machine(xen_suspend, &si, cpumask_of(0));
 137 
 138         /* Resume console as early as possible. */
 139         if (!si.cancelled)
 140                 xen_console_resume();
 141 
 142         raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);
 143 
 144         dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 145 
 146         if (err) {
 147                 pr_err("failed to start xen_suspend: %d\n", err);
 148                 si.cancelled = 1;
 149         }
 150 
 151         xen_arch_resume();
 152 
 153 out_resume:
 154         if (!si.cancelled)
 155                 xs_resume();
 156         else
 157                 xs_suspend_cancel();
 158 
 159         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
 160 
 161 out_thaw:
 162         thaw_processes();
 163 out:
 164         shutting_down = SHUTDOWN_INVALID;
 165 }
 166 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
 167 
 168 struct shutdown_handler {
 169 #define SHUTDOWN_CMD_SIZE 11
 170         const char command[SHUTDOWN_CMD_SIZE];
 171         bool flag;
 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         case SYSTEM_SCHEDULING:
 192                 orderly_poweroff(true);
 193                 break;
 194         case SYSTEM_RUNNING:
 195                 orderly_poweroff(false);
 196                 break;
 197         default:
 198                 /* Don't do it when we are halting/rebooting. */
 199                 pr_info("Ignoring Xen toolstack shutdown.\n");
 200                 break;
 201         }
 202 }
 203 
 204 static void do_reboot(void)
 205 {
 206         shutting_down = SHUTDOWN_POWEROFF; /* ? */
 207         ctrl_alt_del();
 208 }
 209 
 210 static struct shutdown_handler shutdown_handlers[] = {
 211         { "poweroff",   true,   do_poweroff },
 212         { "halt",       false,  do_poweroff },
 213         { "reboot",     true,   do_reboot   },
 214 #ifdef CONFIG_HIBERNATE_CALLBACKS
 215         { "suspend",    true,   do_suspend  },
 216 #endif
 217 };
 218 
 219 static void shutdown_handler(struct xenbus_watch *watch,
 220                              const char *path, const char *token)
 221 {
 222         char *str;
 223         struct xenbus_transaction xbt;
 224         int err;
 225         int idx;
 226 
 227         if (shutting_down != SHUTDOWN_INVALID)
 228                 return;
 229 
 230  again:
 231         err = xenbus_transaction_start(&xbt);
 232         if (err)
 233                 return;
 234 
 235         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
 236         /* Ignore read errors and empty reads. */
 237         if (XENBUS_IS_ERR_READ(str)) {
 238                 xenbus_transaction_end(xbt, 1);
 239                 return;
 240         }
 241 
 242         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 243                 if (strcmp(str, shutdown_handlers[idx].command) == 0)
 244                         break;
 245         }
 246 
 247         /* Only acknowledge commands which we are prepared to handle. */
 248         if (idx < ARRAY_SIZE(shutdown_handlers))
 249                 xenbus_write(xbt, "control", "shutdown", "");
 250 
 251         err = xenbus_transaction_end(xbt, 0);
 252         if (err == -EAGAIN) {
 253                 kfree(str);
 254                 goto again;
 255         }
 256 
 257         if (idx < ARRAY_SIZE(shutdown_handlers)) {
 258                 shutdown_handlers[idx].cb();
 259         } else {
 260                 pr_info("Ignoring shutdown request: %s\n", str);
 261                 shutting_down = SHUTDOWN_INVALID;
 262         }
 263 
 264         kfree(str);
 265 }
 266 
 267 #ifdef CONFIG_MAGIC_SYSRQ
 268 static void sysrq_handler(struct xenbus_watch *watch, const char *path,
 269                           const char *token)
 270 {
 271         char sysrq_key = '\0';
 272         struct xenbus_transaction xbt;
 273         int err;
 274 
 275  again:
 276         err = xenbus_transaction_start(&xbt);
 277         if (err)
 278                 return;
 279         err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key);
 280         if (err < 0) {
 281                 /*
 282                  * The Xenstore watch fires directly after registering it and
 283                  * after a suspend/resume cycle. So ENOENT is no error but
 284                  * might happen in those cases. ERANGE is observed when we get
 285                  * an empty value (''), this happens when we acknowledge the
 286                  * request by writing '\0' below.
 287                  */
 288                 if (err != -ENOENT && err != -ERANGE)
 289                         pr_err("Error %d reading sysrq code in control/sysrq\n",
 290                                err);
 291                 xenbus_transaction_end(xbt, 1);
 292                 return;
 293         }
 294 
 295         if (sysrq_key != '\0') {
 296                 err = xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
 297                 if (err) {
 298                         pr_err("%s: Error %d writing sysrq in control/sysrq\n",
 299                                __func__, err);
 300                         xenbus_transaction_end(xbt, 1);
 301                         return;
 302                 }
 303         }
 304 
 305         err = xenbus_transaction_end(xbt, 0);
 306         if (err == -EAGAIN)
 307                 goto again;
 308 
 309         if (sysrq_key != '\0')
 310                 handle_sysrq(sysrq_key);
 311 }
 312 
 313 static struct xenbus_watch sysrq_watch = {
 314         .node = "control/sysrq",
 315         .callback = sysrq_handler
 316 };
 317 #endif
 318 
 319 static struct xenbus_watch shutdown_watch = {
 320         .node = "control/shutdown",
 321         .callback = shutdown_handler
 322 };
 323 
 324 static struct notifier_block xen_reboot_nb = {
 325         .notifier_call = poweroff_nb,
 326 };
 327 
 328 static int setup_shutdown_watcher(void)
 329 {
 330         int err;
 331         int idx;
 332 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
 333         char node[FEATURE_PATH_SIZE];
 334 
 335         err = register_xenbus_watch(&shutdown_watch);
 336         if (err) {
 337                 pr_err("Failed to set shutdown watcher\n");
 338                 return err;
 339         }
 340 
 341 
 342 #ifdef CONFIG_MAGIC_SYSRQ
 343         err = register_xenbus_watch(&sysrq_watch);
 344         if (err) {
 345                 pr_err("Failed to set sysrq watcher\n");
 346                 return err;
 347         }
 348 #endif
 349 
 350         for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
 351                 if (!shutdown_handlers[idx].flag)
 352                         continue;
 353                 snprintf(node, FEATURE_PATH_SIZE, "feature-%s",
 354                          shutdown_handlers[idx].command);
 355                 err = xenbus_printf(XBT_NIL, "control", node, "%u", 1);
 356                 if (err) {
 357                         pr_err("%s: Error %d writing %s\n", __func__,
 358                                 err, node);
 359                         return err;
 360                 }
 361         }
 362 
 363         return 0;
 364 }
 365 
 366 static int shutdown_event(struct notifier_block *notifier,
 367                           unsigned long event,
 368                           void *data)
 369 {
 370         setup_shutdown_watcher();
 371         return NOTIFY_DONE;
 372 }
 373 
 374 int xen_setup_shutdown_event(void)
 375 {
 376         static struct notifier_block xenstore_notifier = {
 377                 .notifier_call = shutdown_event
 378         };
 379 
 380         if (!xen_domain())
 381                 return -ENODEV;
 382         register_xenstore_notifier(&xenstore_notifier);
 383         register_reboot_notifier(&xen_reboot_nb);
 384 
 385         return 0;
 386 }
 387 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
 388 
 389 subsys_initcall(xen_setup_shutdown_event);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/xen/manage.c

DEFINITIONS
