blob: d0e87cbe157ca5e4634151f8d997e9d66fb66ebc [file] [log] [blame]
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -07001/*
2 * Handle extern requests for shutdown, reboot and sysrq
3 */
4#include <linux/kernel.h>
5#include <linux/err.h>
6#include <linux/reboot.h>
7#include <linux/sysrq.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +01008#include <linux/stop_machine.h>
9#include <linux/freezer.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070010
11#include <xen/xenbus.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010012#include <xen/grant_table.h>
13#include <xen/events.h>
14#include <xen/hvc-console.h>
15#include <xen/xen-ops.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070016
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010017#include <asm/xen/hypercall.h>
18#include <asm/xen/page.h>
19
20enum shutdown_state {
21 SHUTDOWN_INVALID = -1,
22 SHUTDOWN_POWEROFF = 0,
23 SHUTDOWN_SUSPEND = 2,
24 /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
25 report a crash, not be instructed to crash!
26 HALT is the same as POWEROFF, as far as we're concerned. The tools use
27 the distinction when we return the reason code to them. */
28 SHUTDOWN_HALT = 4,
29};
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070030
31/* Ignore multiple shutdown requests. */
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010032static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
33
Jeremy Fitzhardingec7827722008-05-29 09:02:19 +010034#ifdef CONFIG_PM_SLEEP
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010035static int xen_suspend(void *data)
36{
37 int *cancelled = data;
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010038 int err;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010039
40 BUG_ON(!irqs_disabled());
41
42 load_cr3(swapper_pg_dir);
43
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010044 err = device_power_down(PMSG_SUSPEND);
45 if (err) {
46 printk(KERN_ERR "xen_suspend: device_power_down failed: %d\n",
47 err);
48 return err;
49 }
50
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010051 xen_mm_pin_all();
52 gnttab_suspend();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010053 xen_pre_suspend();
54
55 /*
56 * This hypercall returns 1 if suspend was cancelled
57 * or the domain was merely checkpointed, and 0 if it
58 * is resuming in a new domain.
59 */
60 *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
61
62 xen_post_suspend(*cancelled);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010063 gnttab_resume();
64 xen_mm_unpin_all();
65
Stephen Rothwell55ca0892008-07-17 13:09:24 +100066 device_power_up(PMSG_RESUME);
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010067
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010068 if (!*cancelled) {
69 xen_irq_resume();
70 xen_console_resume();
Isaku Yamahataad55db92008-07-08 15:06:32 -070071 xen_timer_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010072 }
73
74 return 0;
75}
76
77static void do_suspend(void)
78{
79 int err;
80 int cancelled = 1;
81
82 shutting_down = SHUTDOWN_SUSPEND;
83
84#ifdef CONFIG_PREEMPT
85 /* If the kernel is preemptible, we need to freeze all the processes
86 to prevent them from being in the middle of a pagetable update
87 during suspend. */
88 err = freeze_processes();
89 if (err) {
90 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
91 return;
92 }
93#endif
94
95 err = device_suspend(PMSG_SUSPEND);
96 if (err) {
97 printk(KERN_ERR "xen suspend: device_suspend %d\n", err);
98 goto out;
99 }
100
101 printk("suspending xenbus...\n");
102 /* XXX use normal device tree? */
103 xenbus_suspend();
104
Rusty Russell37a7c0f2008-08-26 00:19:26 -0500105 err = stop_machine(xen_suspend, &cancelled, &cpumask_of_cpu(0));
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100106 if (err) {
107 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
108 goto out;
109 }
110
Isaku Yamahataad55db92008-07-08 15:06:32 -0700111 if (!cancelled) {
112 xen_arch_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100113 xenbus_resume();
Isaku Yamahataad55db92008-07-08 15:06:32 -0700114 } else
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100115 xenbus_suspend_cancel();
116
Stephen Rothwell55ca0892008-07-17 13:09:24 +1000117 device_resume(PMSG_RESUME);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100118
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +0100119 /* Make sure timer events get retriggered on all CPUs */
120 clock_was_set();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100121out:
122#ifdef CONFIG_PREEMPT
123 thaw_processes();
124#endif
125 shutting_down = SHUTDOWN_INVALID;
126}
Jeremy Fitzhardingec7827722008-05-29 09:02:19 +0100127#endif /* CONFIG_PM_SLEEP */
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700128
129static void shutdown_handler(struct xenbus_watch *watch,
130 const char **vec, unsigned int len)
131{
132 char *str;
133 struct xenbus_transaction xbt;
134 int err;
135
136 if (shutting_down != SHUTDOWN_INVALID)
137 return;
138
139 again:
140 err = xenbus_transaction_start(&xbt);
141 if (err)
142 return;
143
144 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
145 /* Ignore read errors and empty reads. */
146 if (XENBUS_IS_ERR_READ(str)) {
147 xenbus_transaction_end(xbt, 1);
148 return;
149 }
150
151 xenbus_write(xbt, "control", "shutdown", "");
152
153 err = xenbus_transaction_end(xbt, 0);
154 if (err == -EAGAIN) {
155 kfree(str);
156 goto again;
157 }
158
159 if (strcmp(str, "poweroff") == 0 ||
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100160 strcmp(str, "halt") == 0) {
161 shutting_down = SHUTDOWN_POWEROFF;
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700162 orderly_poweroff(false);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100163 } else if (strcmp(str, "reboot") == 0) {
164 shutting_down = SHUTDOWN_POWEROFF; /* ? */
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700165 ctrl_alt_del();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100166#ifdef CONFIG_PM_SLEEP
167 } else if (strcmp(str, "suspend") == 0) {
168 do_suspend();
169#endif
170 } else {
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700171 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
172 shutting_down = SHUTDOWN_INVALID;
173 }
174
175 kfree(str);
176}
177
178static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
179 unsigned int len)
180{
181 char sysrq_key = '\0';
182 struct xenbus_transaction xbt;
183 int err;
184
185 again:
186 err = xenbus_transaction_start(&xbt);
187 if (err)
188 return;
189 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
190 printk(KERN_ERR "Unable to read sysrq code in "
191 "control/sysrq\n");
192 xenbus_transaction_end(xbt, 1);
193 return;
194 }
195
196 if (sysrq_key != '\0')
197 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
198
199 err = xenbus_transaction_end(xbt, 0);
200 if (err == -EAGAIN)
201 goto again;
202
203 if (sysrq_key != '\0')
204 handle_sysrq(sysrq_key, NULL);
205}
206
207static struct xenbus_watch shutdown_watch = {
208 .node = "control/shutdown",
209 .callback = shutdown_handler
210};
211
212static struct xenbus_watch sysrq_watch = {
213 .node = "control/sysrq",
214 .callback = sysrq_handler
215};
216
217static int setup_shutdown_watcher(void)
218{
219 int err;
220
221 err = register_xenbus_watch(&shutdown_watch);
222 if (err) {
223 printk(KERN_ERR "Failed to set shutdown watcher\n");
224 return err;
225 }
226
227 err = register_xenbus_watch(&sysrq_watch);
228 if (err) {
229 printk(KERN_ERR "Failed to set sysrq watcher\n");
230 return err;
231 }
232
233 return 0;
234}
235
236static int shutdown_event(struct notifier_block *notifier,
237 unsigned long event,
238 void *data)
239{
240 setup_shutdown_watcher();
241 return NOTIFY_DONE;
242}
243
244static int __init setup_shutdown_event(void)
245{
246 static struct notifier_block xenstore_notifier = {
247 .notifier_call = shutdown_event
248 };
249 register_xenstore_notifier(&xenstore_notifier);
250
251 return 0;
252}
253
254subsys_initcall(setup_shutdown_event);