blob: 56892a142ee273eef1112ea212792556ecfc806b [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
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010042 err = device_power_down(PMSG_SUSPEND);
43 if (err) {
44 printk(KERN_ERR "xen_suspend: device_power_down failed: %d\n",
45 err);
46 return err;
47 }
Rafael J. Wysocki770824b2009-02-22 18:38:50 +010048 err = sysdev_suspend(PMSG_SUSPEND);
49 if (err) {
50 printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
51 err);
52 device_power_up(PMSG_RESUME);
53 return err;
54 }
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010055
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010056 xen_mm_pin_all();
57 gnttab_suspend();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010058 xen_pre_suspend();
59
60 /*
61 * This hypercall returns 1 if suspend was cancelled
62 * or the domain was merely checkpointed, and 0 if it
63 * is resuming in a new domain.
64 */
65 *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
66
67 xen_post_suspend(*cancelled);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010068 gnttab_resume();
69 xen_mm_unpin_all();
70
Rafael J. Wysocki770824b2009-02-22 18:38:50 +010071 sysdev_resume();
Stephen Rothwell55ca0892008-07-17 13:09:24 +100072 device_power_up(PMSG_RESUME);
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010073
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010074 if (!*cancelled) {
75 xen_irq_resume();
76 xen_console_resume();
Isaku Yamahataad55db92008-07-08 15:06:32 -070077 xen_timer_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010078 }
79
80 return 0;
81}
82
83static void do_suspend(void)
84{
85 int err;
86 int cancelled = 1;
87
88 shutting_down = SHUTDOWN_SUSPEND;
89
90#ifdef CONFIG_PREEMPT
91 /* If the kernel is preemptible, we need to freeze all the processes
92 to prevent them from being in the middle of a pagetable update
93 during suspend. */
94 err = freeze_processes();
95 if (err) {
96 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
97 return;
98 }
99#endif
100
101 err = device_suspend(PMSG_SUSPEND);
102 if (err) {
103 printk(KERN_ERR "xen suspend: device_suspend %d\n", err);
104 goto out;
105 }
106
107 printk("suspending xenbus...\n");
108 /* XXX use normal device tree? */
109 xenbus_suspend();
110
Rusty Russell37a7c0f2008-08-26 00:19:26 -0500111 err = stop_machine(xen_suspend, &cancelled, &cpumask_of_cpu(0));
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100112 if (err) {
113 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
114 goto out;
115 }
116
Isaku Yamahataad55db92008-07-08 15:06:32 -0700117 if (!cancelled) {
118 xen_arch_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100119 xenbus_resume();
Isaku Yamahataad55db92008-07-08 15:06:32 -0700120 } else
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100121 xenbus_suspend_cancel();
122
Stephen Rothwell55ca0892008-07-17 13:09:24 +1000123 device_resume(PMSG_RESUME);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100124
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +0100125 /* Make sure timer events get retriggered on all CPUs */
126 clock_was_set();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100127out:
128#ifdef CONFIG_PREEMPT
129 thaw_processes();
130#endif
131 shutting_down = SHUTDOWN_INVALID;
132}
Jeremy Fitzhardingec7827722008-05-29 09:02:19 +0100133#endif /* CONFIG_PM_SLEEP */
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700134
135static void shutdown_handler(struct xenbus_watch *watch,
136 const char **vec, unsigned int len)
137{
138 char *str;
139 struct xenbus_transaction xbt;
140 int err;
141
142 if (shutting_down != SHUTDOWN_INVALID)
143 return;
144
145 again:
146 err = xenbus_transaction_start(&xbt);
147 if (err)
148 return;
149
150 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
151 /* Ignore read errors and empty reads. */
152 if (XENBUS_IS_ERR_READ(str)) {
153 xenbus_transaction_end(xbt, 1);
154 return;
155 }
156
157 xenbus_write(xbt, "control", "shutdown", "");
158
159 err = xenbus_transaction_end(xbt, 0);
160 if (err == -EAGAIN) {
161 kfree(str);
162 goto again;
163 }
164
165 if (strcmp(str, "poweroff") == 0 ||
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100166 strcmp(str, "halt") == 0) {
167 shutting_down = SHUTDOWN_POWEROFF;
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700168 orderly_poweroff(false);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100169 } else if (strcmp(str, "reboot") == 0) {
170 shutting_down = SHUTDOWN_POWEROFF; /* ? */
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700171 ctrl_alt_del();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100172#ifdef CONFIG_PM_SLEEP
173 } else if (strcmp(str, "suspend") == 0) {
174 do_suspend();
175#endif
176 } else {
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700177 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
178 shutting_down = SHUTDOWN_INVALID;
179 }
180
181 kfree(str);
182}
183
184static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
185 unsigned int len)
186{
187 char sysrq_key = '\0';
188 struct xenbus_transaction xbt;
189 int err;
190
191 again:
192 err = xenbus_transaction_start(&xbt);
193 if (err)
194 return;
195 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
196 printk(KERN_ERR "Unable to read sysrq code in "
197 "control/sysrq\n");
198 xenbus_transaction_end(xbt, 1);
199 return;
200 }
201
202 if (sysrq_key != '\0')
203 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
204
205 err = xenbus_transaction_end(xbt, 0);
206 if (err == -EAGAIN)
207 goto again;
208
209 if (sysrq_key != '\0')
210 handle_sysrq(sysrq_key, NULL);
211}
212
213static struct xenbus_watch shutdown_watch = {
214 .node = "control/shutdown",
215 .callback = shutdown_handler
216};
217
218static struct xenbus_watch sysrq_watch = {
219 .node = "control/sysrq",
220 .callback = sysrq_handler
221};
222
223static int setup_shutdown_watcher(void)
224{
225 int err;
226
227 err = register_xenbus_watch(&shutdown_watch);
228 if (err) {
229 printk(KERN_ERR "Failed to set shutdown watcher\n");
230 return err;
231 }
232
233 err = register_xenbus_watch(&sysrq_watch);
234 if (err) {
235 printk(KERN_ERR "Failed to set sysrq watcher\n");
236 return err;
237 }
238
239 return 0;
240}
241
242static int shutdown_event(struct notifier_block *notifier,
243 unsigned long event,
244 void *data)
245{
246 setup_shutdown_watcher();
247 return NOTIFY_DONE;
248}
249
250static int __init setup_shutdown_event(void)
251{
252 static struct notifier_block xenstore_notifier = {
253 .notifier_call = shutdown_event
254 };
255 register_xenstore_notifier(&xenstore_notifier);
256
257 return 0;
258}
259
260subsys_initcall(setup_shutdown_event);