2 * Handle extern requests for shutdown, reboot and sysrq
4 #include <linux/kernel.h>
6 #include <linux/slab.h>
7 #include <linux/reboot.h>
8 #include <linux/sysrq.h>
9 #include <linux/stop_machine.h>
10 #include <linux/freezer.h>
11 #include <linux/syscore_ops.h>
12 #include <linux/export.h>
15 #include <xen/xenbus.h>
16 #include <xen/grant_table.h>
17 #include <xen/events.h>
18 #include <xen/hvc-console.h>
19 #include <xen/xen-ops.h>
21 #include <asm/xen/hypercall.h>
22 #include <asm/xen/page.h>
23 #include <asm/xen/hypervisor.h>
26 SHUTDOWN_INVALID = -1,
27 SHUTDOWN_POWEROFF = 0,
29 /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
30 report a crash, not be instructed to crash!
31 HALT is the same as POWEROFF, as far as we're concerned. The tools use
32 the distinction when we return the reason code to them. */
36 /* Ignore multiple shutdown requests. */
37 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
41 unsigned long arg; /* extra hypercall argument */
43 void (*post)(int cancelled);
46 static void xen_hvm_post_suspend(int cancelled)
48 xen_arch_hvm_post_suspend(cancelled);
52 static void xen_pre_suspend(void)
56 xen_arch_pre_suspend();
59 static void xen_post_suspend(int cancelled)
61 xen_arch_post_suspend(cancelled);
66 #ifdef CONFIG_HIBERNATE_CALLBACKS
67 static int xen_suspend(void *data)
69 struct suspend_info *si = data;
72 BUG_ON(!irqs_disabled());
74 err = syscore_suspend();
76 printk(KERN_ERR "xen_suspend: system core suspend failed: %d\n",
85 * This hypercall returns 1 if suspend was cancelled
86 * or the domain was merely checkpointed, and 0 if it
87 * is resuming in a new domain.
89 si->cancelled = HYPERVISOR_suspend(si->arg);
92 si->post(si->cancelled);
104 static void do_suspend(void)
107 struct suspend_info si;
109 shutting_down = SHUTDOWN_SUSPEND;
111 err = freeze_processes();
113 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
117 err = dpm_suspend_start(PMSG_FREEZE);
119 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
123 printk(KERN_DEBUG "suspending xenstore...\n");
126 err = dpm_suspend_noirq(PMSG_FREEZE);
128 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
134 if (xen_hvm_domain()) {
137 si.post = &xen_hvm_post_suspend;
139 si.arg = virt_to_mfn(xen_start_info);
140 si.pre = &xen_pre_suspend;
141 si.post = &xen_post_suspend;
144 err = stop_machine(xen_suspend, &si, cpumask_of(0));
146 /* Resume console as early as possible. */
148 xen_console_resume();
150 dpm_resume_noirq(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
153 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
164 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
166 /* Make sure timer events get retriggered on all CPUs */
172 shutting_down = SHUTDOWN_INVALID;
174 #endif /* CONFIG_HIBERNATE_CALLBACKS */
176 struct shutdown_handler {
181 static void do_poweroff(void)
183 shutting_down = SHUTDOWN_POWEROFF;
184 orderly_poweroff(false);
187 static void do_reboot(void)
189 shutting_down = SHUTDOWN_POWEROFF; /* ? */
193 static void shutdown_handler(struct xenbus_watch *watch,
194 const char **vec, unsigned int len)
197 struct xenbus_transaction xbt;
199 static struct shutdown_handler handlers[] = {
200 { "poweroff", do_poweroff },
201 { "halt", do_poweroff },
202 { "reboot", do_reboot },
203 #ifdef CONFIG_HIBERNATE_CALLBACKS
204 { "suspend", do_suspend },
208 static struct shutdown_handler *handler;
210 if (shutting_down != SHUTDOWN_INVALID)
214 err = xenbus_transaction_start(&xbt);
218 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
219 /* Ignore read errors and empty reads. */
220 if (XENBUS_IS_ERR_READ(str)) {
221 xenbus_transaction_end(xbt, 1);
225 for (handler = &handlers[0]; handler->command; handler++) {
226 if (strcmp(str, handler->command) == 0)
230 /* Only acknowledge commands which we are prepared to handle. */
232 xenbus_write(xbt, "control", "shutdown", "");
234 err = xenbus_transaction_end(xbt, 0);
235 if (err == -EAGAIN) {
243 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
244 shutting_down = SHUTDOWN_INVALID;
250 #ifdef CONFIG_MAGIC_SYSRQ
251 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
254 char sysrq_key = '\0';
255 struct xenbus_transaction xbt;
259 err = xenbus_transaction_start(&xbt);
262 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
263 printk(KERN_ERR "Unable to read sysrq code in "
265 xenbus_transaction_end(xbt, 1);
269 if (sysrq_key != '\0')
270 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
272 err = xenbus_transaction_end(xbt, 0);
276 if (sysrq_key != '\0')
277 handle_sysrq(sysrq_key);
280 static struct xenbus_watch sysrq_watch = {
281 .node = "control/sysrq",
282 .callback = sysrq_handler
286 static struct xenbus_watch shutdown_watch = {
287 .node = "control/shutdown",
288 .callback = shutdown_handler
291 static int setup_shutdown_watcher(void)
295 err = register_xenbus_watch(&shutdown_watch);
297 printk(KERN_ERR "Failed to set shutdown watcher\n");
301 #ifdef CONFIG_MAGIC_SYSRQ
302 err = register_xenbus_watch(&sysrq_watch);
304 printk(KERN_ERR "Failed to set sysrq watcher\n");
312 static int shutdown_event(struct notifier_block *notifier,
316 setup_shutdown_watcher();
320 int xen_setup_shutdown_event(void)
322 static struct notifier_block xenstore_notifier = {
323 .notifier_call = shutdown_event
328 register_xenstore_notifier(&xenstore_notifier);
332 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
334 subsys_initcall(xen_setup_shutdown_event);