xenbus: Xen paravirtualised PCI hotplug support.
[linux-2.6.git] / drivers / xen / manage.c
1 /*
2  * Handle extern requests for shutdown, reboot and sysrq
3  */
4 #include <linux/kernel.h>
5 #include <linux/err.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
12 #include <xen/xen.h>
13 #include <xen/xenbus.h>
14 #include <xen/grant_table.h>
15 #include <xen/events.h>
16 #include <xen/hvc-console.h>
17 #include <xen/xen-ops.h>
18
19 #include <asm/xen/hypercall.h>
20 #include <asm/xen/page.h>
21 #include <asm/xen/hypervisor.h>
22
23 enum shutdown_state {
24         SHUTDOWN_INVALID = -1,
25         SHUTDOWN_POWEROFF = 0,
26         SHUTDOWN_SUSPEND = 2,
27         /* Code 3 is SHUTDOWN_CRASH, which we don't use because the domain can only
28            report a crash, not be instructed to crash!
29            HALT is the same as POWEROFF, as far as we're concerned.  The tools use
30            the distinction when we return the reason code to them.  */
31          SHUTDOWN_HALT = 4,
32 };
33
34 /* Ignore multiple shutdown requests. */
35 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
36
37 #ifdef CONFIG_PM_SLEEP
38 static int xen_hvm_suspend(void *data)
39 {
40         struct sched_shutdown r = { .reason = SHUTDOWN_suspend };
41         int *cancelled = data;
42
43         BUG_ON(!irqs_disabled());
44
45         *cancelled = HYPERVISOR_sched_op(SCHEDOP_shutdown, &r);
46
47         xen_hvm_post_suspend(*cancelled);
48         gnttab_resume();
49
50         if (!*cancelled) {
51                 xen_irq_resume();
52                 xen_timer_resume();
53         }
54
55         return 0;
56 }
57
58 static int xen_suspend(void *data)
59 {
60         int err;
61         int *cancelled = data;
62
63         BUG_ON(!irqs_disabled());
64
65         err = sysdev_suspend(PMSG_SUSPEND);
66         if (err) {
67                 printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
68                         err);
69                 return err;
70         }
71
72         xen_mm_pin_all();
73         gnttab_suspend();
74         xen_pre_suspend();
75
76         /*
77          * This hypercall returns 1 if suspend was cancelled
78          * or the domain was merely checkpointed, and 0 if it
79          * is resuming in a new domain.
80          */
81         *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
82
83         xen_post_suspend(*cancelled);
84         gnttab_resume();
85         xen_mm_unpin_all();
86
87         if (!*cancelled) {
88                 xen_irq_resume();
89                 xen_console_resume();
90                 xen_timer_resume();
91         }
92
93         sysdev_resume();
94
95         return 0;
96 }
97
98 static void do_suspend(void)
99 {
100         int err;
101         int cancelled = 1;
102
103         shutting_down = SHUTDOWN_SUSPEND;
104
105 #ifdef CONFIG_PREEMPT
106         /* If the kernel is preemptible, we need to freeze all the processes
107            to prevent them from being in the middle of a pagetable update
108            during suspend. */
109         err = freeze_processes();
110         if (err) {
111                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
112                 goto out;
113         }
114 #endif
115
116         err = dpm_suspend_start(PMSG_SUSPEND);
117         if (err) {
118                 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
119                 goto out_thaw;
120         }
121
122         printk(KERN_DEBUG "suspending xenstore...\n");
123         xs_suspend();
124
125         err = dpm_suspend_noirq(PMSG_SUSPEND);
126         if (err) {
127                 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
128                 goto out_resume;
129         }
130
131         if (xen_hvm_domain())
132                 err = stop_machine(xen_hvm_suspend, &cancelled, cpumask_of(0));
133         else
134                 err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
135
136         dpm_resume_noirq(PMSG_RESUME);
137
138         if (err) {
139                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
140                 cancelled = 1;
141         }
142
143 out_resume:
144         if (!cancelled) {
145                 xen_arch_resume();
146                 xs_resume();
147         } else
148                 xs_suspend_cancel();
149
150         dpm_resume_end(PMSG_RESUME);
151
152         /* Make sure timer events get retriggered on all CPUs */
153         clock_was_set();
154
155 out_thaw:
156 #ifdef CONFIG_PREEMPT
157         thaw_processes();
158 out:
159 #endif
160         shutting_down = SHUTDOWN_INVALID;
161 }
162 #endif  /* CONFIG_PM_SLEEP */
163
164 static void shutdown_handler(struct xenbus_watch *watch,
165                              const char **vec, unsigned int len)
166 {
167         char *str;
168         struct xenbus_transaction xbt;
169         int err;
170
171         if (shutting_down != SHUTDOWN_INVALID)
172                 return;
173
174  again:
175         err = xenbus_transaction_start(&xbt);
176         if (err)
177                 return;
178
179         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
180         /* Ignore read errors and empty reads. */
181         if (XENBUS_IS_ERR_READ(str)) {
182                 xenbus_transaction_end(xbt, 1);
183                 return;
184         }
185
186         xenbus_write(xbt, "control", "shutdown", "");
187
188         err = xenbus_transaction_end(xbt, 0);
189         if (err == -EAGAIN) {
190                 kfree(str);
191                 goto again;
192         }
193
194         if (strcmp(str, "poweroff") == 0 ||
195             strcmp(str, "halt") == 0) {
196                 shutting_down = SHUTDOWN_POWEROFF;
197                 orderly_poweroff(false);
198         } else if (strcmp(str, "reboot") == 0) {
199                 shutting_down = SHUTDOWN_POWEROFF; /* ? */
200                 ctrl_alt_del();
201 #ifdef CONFIG_PM_SLEEP
202         } else if (strcmp(str, "suspend") == 0) {
203                 do_suspend();
204 #endif
205         } else {
206                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
207                 shutting_down = SHUTDOWN_INVALID;
208         }
209
210         kfree(str);
211 }
212
213 #ifdef CONFIG_MAGIC_SYSRQ
214 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
215                           unsigned int len)
216 {
217         char sysrq_key = '\0';
218         struct xenbus_transaction xbt;
219         int err;
220
221  again:
222         err = xenbus_transaction_start(&xbt);
223         if (err)
224                 return;
225         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
226                 printk(KERN_ERR "Unable to read sysrq code in "
227                        "control/sysrq\n");
228                 xenbus_transaction_end(xbt, 1);
229                 return;
230         }
231
232         if (sysrq_key != '\0')
233                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
234
235         err = xenbus_transaction_end(xbt, 0);
236         if (err == -EAGAIN)
237                 goto again;
238
239         if (sysrq_key != '\0')
240                 handle_sysrq(sysrq_key);
241 }
242
243 static struct xenbus_watch sysrq_watch = {
244         .node = "control/sysrq",
245         .callback = sysrq_handler
246 };
247 #endif
248
249 static struct xenbus_watch shutdown_watch = {
250         .node = "control/shutdown",
251         .callback = shutdown_handler
252 };
253
254 static int setup_shutdown_watcher(void)
255 {
256         int err;
257
258         err = register_xenbus_watch(&shutdown_watch);
259         if (err) {
260                 printk(KERN_ERR "Failed to set shutdown watcher\n");
261                 return err;
262         }
263
264 #ifdef CONFIG_MAGIC_SYSRQ
265         err = register_xenbus_watch(&sysrq_watch);
266         if (err) {
267                 printk(KERN_ERR "Failed to set sysrq watcher\n");
268                 return err;
269         }
270 #endif
271
272         return 0;
273 }
274
275 static int shutdown_event(struct notifier_block *notifier,
276                           unsigned long event,
277                           void *data)
278 {
279         setup_shutdown_watcher();
280         return NOTIFY_DONE;
281 }
282
283 static int __init __setup_shutdown_event(void)
284 {
285         /* Delay initialization in the PV on HVM case */
286         if (xen_hvm_domain())
287                 return 0;
288
289         if (!xen_pv_domain())
290                 return -ENODEV;
291
292         return xen_setup_shutdown_event();
293 }
294
295 int xen_setup_shutdown_event(void)
296 {
297         static struct notifier_block xenstore_notifier = {
298                 .notifier_call = shutdown_event
299         };
300         register_xenstore_notifier(&xenstore_notifier);
301
302         return 0;
303 }
304 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
305
306 subsys_initcall(__setup_shutdown_event);