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 int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused)
207 shutting_down = SHUTDOWN_POWEROFF;
213 static void do_poweroff(void)
215 switch (system_state) {
217 orderly_poweroff(true);
220 orderly_poweroff(false);
223 /* Don't do it when we are halting/rebooting. */
224 pr_info("Ignoring Xen toolstack shutdown.\n");
229 static void do_reboot(void)
231 shutting_down = SHUTDOWN_POWEROFF; /* ? */
235 static void shutdown_handler(struct xenbus_watch *watch,
236 const char **vec, unsigned int len)
239 struct xenbus_transaction xbt;
241 static struct shutdown_handler handlers[] = {
242 { "poweroff", do_poweroff },
243 { "halt", do_poweroff },
244 { "reboot", do_reboot },
245 #ifdef CONFIG_HIBERNATE_CALLBACKS
246 { "suspend", do_suspend },
250 static struct shutdown_handler *handler;
252 if (shutting_down != SHUTDOWN_INVALID)
256 err = xenbus_transaction_start(&xbt);
260 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
261 /* Ignore read errors and empty reads. */
262 if (XENBUS_IS_ERR_READ(str)) {
263 xenbus_transaction_end(xbt, 1);
267 for (handler = &handlers[0]; handler->command; handler++) {
268 if (strcmp(str, handler->command) == 0)
272 /* Only acknowledge commands which we are prepared to handle. */
274 xenbus_write(xbt, "control", "shutdown", "");
276 err = xenbus_transaction_end(xbt, 0);
277 if (err == -EAGAIN) {
285 pr_info("Ignoring shutdown request: %s\n", str);
286 shutting_down = SHUTDOWN_INVALID;
292 #ifdef CONFIG_MAGIC_SYSRQ
293 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
296 char sysrq_key = '\0';
297 struct xenbus_transaction xbt;
301 err = xenbus_transaction_start(&xbt);
304 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
305 pr_err("Unable to read sysrq code in control/sysrq\n");
306 xenbus_transaction_end(xbt, 1);
310 if (sysrq_key != '\0')
311 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
313 err = xenbus_transaction_end(xbt, 0);
317 if (sysrq_key != '\0')
318 handle_sysrq(sysrq_key);
321 static struct xenbus_watch sysrq_watch = {
322 .node = "control/sysrq",
323 .callback = sysrq_handler
327 static struct xenbus_watch shutdown_watch = {
328 .node = "control/shutdown",
329 .callback = shutdown_handler
332 static struct notifier_block xen_reboot_nb = {
333 .notifier_call = poweroff_nb,
336 static int setup_shutdown_watcher(void)
340 err = register_xenbus_watch(&shutdown_watch);
342 pr_err("Failed to set shutdown watcher\n");
347 #ifdef CONFIG_MAGIC_SYSRQ
348 err = register_xenbus_watch(&sysrq_watch);
350 pr_err("Failed to set sysrq watcher\n");
358 static int shutdown_event(struct notifier_block *notifier,
362 setup_shutdown_watcher();
366 int xen_setup_shutdown_event(void)
368 static struct notifier_block xenstore_notifier = {
369 .notifier_call = shutdown_event
374 register_xenstore_notifier(&xenstore_notifier);
375 register_reboot_notifier(&xen_reboot_nb);
379 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
381 subsys_initcall(xen_setup_shutdown_event);