2 * Handle extern requests for shutdown, reboot and sysrq
5 #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
7 #include <linux/kernel.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>
18 #include <xen/xenbus.h>
19 #include <xen/grant_table.h>
20 #include <xen/events.h>
21 #include <xen/hvc-console.h>
23 #include <xen/xen-ops.h>
25 #include <asm/xen/hypercall.h>
26 #include <asm/xen/hypervisor.h>
29 SHUTDOWN_INVALID = -1,
30 SHUTDOWN_POWEROFF = 0,
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. */
39 /* Ignore multiple shutdown requests. */
40 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
46 static RAW_NOTIFIER_HEAD(xen_resume_notifier);
48 void xen_resume_notifier_register(struct notifier_block *nb)
50 raw_notifier_chain_register(&xen_resume_notifier, nb);
52 EXPORT_SYMBOL_GPL(xen_resume_notifier_register);
54 void xen_resume_notifier_unregister(struct notifier_block *nb)
56 raw_notifier_chain_unregister(&xen_resume_notifier, nb);
58 EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister);
60 #ifdef CONFIG_HIBERNATE_CALLBACKS
61 static int xen_suspend(void *data)
63 struct suspend_info *si = data;
66 BUG_ON(!irqs_disabled());
68 err = syscore_suspend();
70 pr_err("%s: system core suspend failed: %d\n", __func__, err);
75 xen_arch_pre_suspend();
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.
82 si->cancelled = HYPERVISOR_suspend(xen_pv_domain()
83 ? virt_to_gfn(xen_start_info)
86 xen_arch_post_suspend(si->cancelled);
99 static void do_suspend(void)
102 struct suspend_info si;
104 shutting_down = SHUTDOWN_SUSPEND;
106 err = freeze_processes();
108 pr_err("%s: freeze processes failed %d\n", __func__, err);
112 err = freeze_kernel_threads();
114 pr_err("%s: freeze kernel threads failed %d\n", __func__, err);
118 err = dpm_suspend_start(PMSG_FREEZE);
120 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
124 printk(KERN_DEBUG "suspending xenstore...\n");
127 err = dpm_suspend_end(PMSG_FREEZE);
129 pr_err("dpm_suspend_end failed: %d\n", err);
138 err = stop_machine(xen_suspend, &si, cpumask_of(0));
140 /* Resume console as early as possible. */
142 xen_console_resume();
144 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);
146 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
149 pr_err("failed to start xen_suspend: %d\n", err);
161 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
166 shutting_down = SHUTDOWN_INVALID;
168 #endif /* CONFIG_HIBERNATE_CALLBACKS */
170 struct shutdown_handler {
171 #define SHUTDOWN_CMD_SIZE 11
172 const char command[SHUTDOWN_CMD_SIZE];
177 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused)
183 shutting_down = SHUTDOWN_POWEROFF;
189 static void do_poweroff(void)
191 switch (system_state) {
193 case SYSTEM_SCHEDULING:
194 orderly_poweroff(true);
197 orderly_poweroff(false);
200 /* Don't do it when we are halting/rebooting. */
201 pr_info("Ignoring Xen toolstack shutdown.\n");
206 static void do_reboot(void)
208 shutting_down = SHUTDOWN_POWEROFF; /* ? */
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 },
221 static void shutdown_handler(struct xenbus_watch *watch,
222 const char *path, const char *token)
225 struct xenbus_transaction xbt;
229 if (shutting_down != SHUTDOWN_INVALID)
233 err = xenbus_transaction_start(&xbt);
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);
244 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
245 if (strcmp(str, shutdown_handlers[idx].command) == 0)
249 /* Only acknowledge commands which we are prepared to handle. */
250 if (idx < ARRAY_SIZE(shutdown_handlers))
251 xenbus_write(xbt, "control", "shutdown", "");
253 err = xenbus_transaction_end(xbt, 0);
254 if (err == -EAGAIN) {
259 if (idx < ARRAY_SIZE(shutdown_handlers)) {
260 shutdown_handlers[idx].cb();
262 pr_info("Ignoring shutdown request: %s\n", str);
263 shutting_down = SHUTDOWN_INVALID;
269 #ifdef CONFIG_MAGIC_SYSRQ
270 static void sysrq_handler(struct xenbus_watch *watch, const char *path,
273 char sysrq_key = '\0';
274 struct xenbus_transaction xbt;
278 err = xenbus_transaction_start(&xbt);
281 err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key);
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.
290 if (err != -ENOENT && err != -ERANGE)
291 pr_err("Error %d reading sysrq code in control/sysrq\n",
293 xenbus_transaction_end(xbt, 1);
297 if (sysrq_key != '\0') {
298 err = xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
300 pr_err("%s: Error %d writing sysrq in control/sysrq\n",
302 xenbus_transaction_end(xbt, 1);
307 err = xenbus_transaction_end(xbt, 0);
311 if (sysrq_key != '\0')
312 handle_sysrq(sysrq_key);
315 static struct xenbus_watch sysrq_watch = {
316 .node = "control/sysrq",
317 .callback = sysrq_handler
321 static struct xenbus_watch shutdown_watch = {
322 .node = "control/shutdown",
323 .callback = shutdown_handler
326 static struct notifier_block xen_reboot_nb = {
327 .notifier_call = poweroff_nb,
330 static int setup_shutdown_watcher(void)
334 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
335 char node[FEATURE_PATH_SIZE];
337 err = register_xenbus_watch(&shutdown_watch);
339 pr_err("Failed to set shutdown watcher\n");
344 #ifdef CONFIG_MAGIC_SYSRQ
345 err = register_xenbus_watch(&sysrq_watch);
347 pr_err("Failed to set sysrq watcher\n");
352 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
353 if (!shutdown_handlers[idx].flag)
355 snprintf(node, FEATURE_PATH_SIZE, "feature-%s",
356 shutdown_handlers[idx].command);
357 err = xenbus_printf(XBT_NIL, "control", node, "%u", 1);
359 pr_err("%s: Error %d writing %s\n", __func__,
368 static int shutdown_event(struct notifier_block *notifier,
372 setup_shutdown_watcher();
376 int xen_setup_shutdown_event(void)
378 static struct notifier_block xenstore_notifier = {
379 .notifier_call = shutdown_event
384 register_xenstore_notifier(&xenstore_notifier);
385 register_reboot_notifier(&xen_reboot_nb);
389 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
391 subsys_initcall(xen_setup_shutdown_event);