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>
22 #include <xen/xen-ops.h>
24 #include <asm/xen/hypercall.h>
25 #include <asm/xen/page.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;
44 unsigned long arg; /* extra hypercall argument */
46 void (*post)(int cancelled);
49 static RAW_NOTIFIER_HEAD(xen_resume_notifier);
51 void xen_resume_notifier_register(struct notifier_block *nb)
53 raw_notifier_chain_register(&xen_resume_notifier, nb);
55 EXPORT_SYMBOL_GPL(xen_resume_notifier_register);
57 void xen_resume_notifier_unregister(struct notifier_block *nb)
59 raw_notifier_chain_unregister(&xen_resume_notifier, nb);
61 EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister);
63 #ifdef CONFIG_HIBERNATE_CALLBACKS
64 static void xen_hvm_post_suspend(int cancelled)
66 xen_arch_hvm_post_suspend(cancelled);
70 static void xen_pre_suspend(void)
74 xen_arch_pre_suspend();
77 static void xen_post_suspend(int cancelled)
79 xen_arch_post_suspend(cancelled);
84 static int xen_suspend(void *data)
86 struct suspend_info *si = data;
89 BUG_ON(!irqs_disabled());
91 err = syscore_suspend();
93 pr_err("%s: system core suspend failed: %d\n", __func__, err);
101 * This hypercall returns 1 if suspend was cancelled
102 * or the domain was merely checkpointed, and 0 if it
103 * is resuming in a new domain.
105 si->cancelled = HYPERVISOR_suspend(si->arg);
108 si->post(si->cancelled);
110 if (!si->cancelled) {
112 xen_console_resume();
121 static void do_suspend(void)
124 struct suspend_info si;
126 shutting_down = SHUTDOWN_SUSPEND;
128 #ifdef CONFIG_PREEMPT
129 /* If the kernel is preemptible, we need to freeze all the processes
130 to prevent them from being in the middle of a pagetable update
132 err = freeze_processes();
134 pr_err("%s: freeze failed %d\n", __func__, err);
139 err = dpm_suspend_start(PMSG_FREEZE);
141 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
145 printk(KERN_DEBUG "suspending xenstore...\n");
148 err = dpm_suspend_end(PMSG_FREEZE);
150 pr_err("dpm_suspend_end failed: %d\n", err);
157 if (xen_hvm_domain()) {
160 si.post = &xen_hvm_post_suspend;
162 si.arg = virt_to_mfn(xen_start_info);
163 si.pre = &xen_pre_suspend;
164 si.post = &xen_post_suspend;
167 err = stop_machine(xen_suspend, &si, cpumask_of(0));
169 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);
171 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
174 pr_err("failed to start xen_suspend: %d\n", err);
185 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
188 #ifdef CONFIG_PREEMPT
192 shutting_down = SHUTDOWN_INVALID;
194 #endif /* CONFIG_HIBERNATE_CALLBACKS */
196 struct shutdown_handler {
201 static void do_poweroff(void)
203 shutting_down = SHUTDOWN_POWEROFF;
204 orderly_poweroff(false);
207 static void do_reboot(void)
209 shutting_down = SHUTDOWN_POWEROFF; /* ? */
213 static void shutdown_handler(struct xenbus_watch *watch,
214 const char **vec, unsigned int len)
217 struct xenbus_transaction xbt;
219 static struct shutdown_handler handlers[] = {
220 { "poweroff", do_poweroff },
221 { "halt", do_poweroff },
222 { "reboot", do_reboot },
223 #ifdef CONFIG_HIBERNATE_CALLBACKS
224 { "suspend", do_suspend },
228 static struct shutdown_handler *handler;
230 if (shutting_down != SHUTDOWN_INVALID)
234 err = xenbus_transaction_start(&xbt);
238 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
239 /* Ignore read errors and empty reads. */
240 if (XENBUS_IS_ERR_READ(str)) {
241 xenbus_transaction_end(xbt, 1);
245 for (handler = &handlers[0]; handler->command; handler++) {
246 if (strcmp(str, handler->command) == 0)
250 /* Only acknowledge commands which we are prepared to handle. */
252 xenbus_write(xbt, "control", "shutdown", "");
254 err = xenbus_transaction_end(xbt, 0);
255 if (err == -EAGAIN) {
263 pr_info("Ignoring shutdown request: %s\n", str);
264 shutting_down = SHUTDOWN_INVALID;
270 #ifdef CONFIG_MAGIC_SYSRQ
271 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
274 char sysrq_key = '\0';
275 struct xenbus_transaction xbt;
279 err = xenbus_transaction_start(&xbt);
282 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
283 pr_err("Unable to read sysrq code in control/sysrq\n");
284 xenbus_transaction_end(xbt, 1);
288 if (sysrq_key != '\0')
289 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
291 err = xenbus_transaction_end(xbt, 0);
295 if (sysrq_key != '\0')
296 handle_sysrq(sysrq_key);
299 static struct xenbus_watch sysrq_watch = {
300 .node = "control/sysrq",
301 .callback = sysrq_handler
305 static struct xenbus_watch shutdown_watch = {
306 .node = "control/shutdown",
307 .callback = shutdown_handler
310 static int setup_shutdown_watcher(void)
314 err = register_xenbus_watch(&shutdown_watch);
316 pr_err("Failed to set shutdown watcher\n");
320 #ifdef CONFIG_MAGIC_SYSRQ
321 err = register_xenbus_watch(&sysrq_watch);
323 pr_err("Failed to set sysrq watcher\n");
331 static int shutdown_event(struct notifier_block *notifier,
335 setup_shutdown_watcher();
339 int xen_setup_shutdown_event(void)
341 static struct notifier_block xenstore_notifier = {
342 .notifier_call = shutdown_event
347 register_xenstore_notifier(&xenstore_notifier);
351 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
353 subsys_initcall(xen_setup_shutdown_event);