Merge commit 'origin/master' into for-linus/xen/master
[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/reboot.h>
7 #include <linux/sysrq.h>
8 #include <linux/stop_machine.h>
9 #include <linux/freezer.h>
10
11 #include <xen/xenbus.h>
12 #include <xen/grant_table.h>
13 #include <xen/events.h>
14 #include <xen/hvc-console.h>
15 #include <xen/xen-ops.h>
16
17 #include <asm/xen/hypercall.h>
18 #include <asm/xen/page.h>
19
20 enum 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 };
30
31 /* Ignore multiple shutdown requests. */
32 static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
33
34 #ifdef CONFIG_PM_SLEEP
35 static int xen_suspend(void *data)
36 {
37         int *cancelled = data;
38         int err;
39
40         BUG_ON(!irqs_disabled());
41
42         err = sysdev_suspend(PMSG_SUSPEND);
43         if (err) {
44                 printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
45                         err);
46                 device_power_up(PMSG_RESUME);
47                 return err;
48         }
49
50         xen_mm_pin_all();
51         gnttab_suspend();
52         xen_pre_suspend();
53
54         /*
55          * This hypercall returns 1 if suspend was cancelled
56          * or the domain was merely checkpointed, and 0 if it
57          * is resuming in a new domain.
58          */
59         *cancelled = HYPERVISOR_suspend(virt_to_mfn(xen_start_info));
60
61         xen_post_suspend(*cancelled);
62         gnttab_resume();
63         xen_mm_unpin_all();
64
65         if (!*cancelled) {
66                 xen_irq_resume();
67                 xen_console_resume();
68                 xen_timer_resume();
69         }
70
71         sysdev_resume();
72         device_power_up(PMSG_RESUME);
73
74         return 0;
75 }
76
77 static 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(KERN_DEBUG "suspending xenstore...\n");
102         xs_suspend();
103
104         err = device_power_down(PMSG_SUSPEND);
105         if (err) {
106                 printk(KERN_ERR "device_power_down failed: %d\n", err);
107                 goto resume_devices;
108         }
109
110         err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
111         if (err) {
112                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
113                 goto out;
114         }
115
116         if (!cancelled) {
117                 xen_arch_resume();
118                 xs_resume();
119         } else
120                 xs_suspend_cancel();
121
122         device_power_up(PMSG_RESUME);
123
124 resume_devices:
125         device_resume(PMSG_RESUME);
126
127         /* Make sure timer events get retriggered on all CPUs */
128         clock_was_set();
129 out:
130 #ifdef CONFIG_PREEMPT
131         thaw_processes();
132 #endif
133         shutting_down = SHUTDOWN_INVALID;
134 }
135 #endif  /* CONFIG_PM_SLEEP */
136
137 static void shutdown_handler(struct xenbus_watch *watch,
138                              const char **vec, unsigned int len)
139 {
140         char *str;
141         struct xenbus_transaction xbt;
142         int err;
143
144         if (shutting_down != SHUTDOWN_INVALID)
145                 return;
146
147  again:
148         err = xenbus_transaction_start(&xbt);
149         if (err)
150                 return;
151
152         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
153         /* Ignore read errors and empty reads. */
154         if (XENBUS_IS_ERR_READ(str)) {
155                 xenbus_transaction_end(xbt, 1);
156                 return;
157         }
158
159         xenbus_write(xbt, "control", "shutdown", "");
160
161         err = xenbus_transaction_end(xbt, 0);
162         if (err == -EAGAIN) {
163                 kfree(str);
164                 goto again;
165         }
166
167         if (strcmp(str, "poweroff") == 0 ||
168             strcmp(str, "halt") == 0) {
169                 shutting_down = SHUTDOWN_POWEROFF;
170                 orderly_poweroff(false);
171         } else if (strcmp(str, "reboot") == 0) {
172                 shutting_down = SHUTDOWN_POWEROFF; /* ? */
173                 ctrl_alt_del();
174 #ifdef CONFIG_PM_SLEEP
175         } else if (strcmp(str, "suspend") == 0) {
176                 do_suspend();
177 #endif
178         } else {
179                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
180                 shutting_down = SHUTDOWN_INVALID;
181         }
182
183         kfree(str);
184 }
185
186 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
187                           unsigned int len)
188 {
189         char sysrq_key = '\0';
190         struct xenbus_transaction xbt;
191         int err;
192
193  again:
194         err = xenbus_transaction_start(&xbt);
195         if (err)
196                 return;
197         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
198                 printk(KERN_ERR "Unable to read sysrq code in "
199                        "control/sysrq\n");
200                 xenbus_transaction_end(xbt, 1);
201                 return;
202         }
203
204         if (sysrq_key != '\0')
205                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
206
207         err = xenbus_transaction_end(xbt, 0);
208         if (err == -EAGAIN)
209                 goto again;
210
211         if (sysrq_key != '\0')
212                 handle_sysrq(sysrq_key, NULL);
213 }
214
215 static struct xenbus_watch shutdown_watch = {
216         .node = "control/shutdown",
217         .callback = shutdown_handler
218 };
219
220 static struct xenbus_watch sysrq_watch = {
221         .node = "control/sysrq",
222         .callback = sysrq_handler
223 };
224
225 static int setup_shutdown_watcher(void)
226 {
227         int err;
228
229         err = register_xenbus_watch(&shutdown_watch);
230         if (err) {
231                 printk(KERN_ERR "Failed to set shutdown watcher\n");
232                 return err;
233         }
234
235         err = register_xenbus_watch(&sysrq_watch);
236         if (err) {
237                 printk(KERN_ERR "Failed to set sysrq watcher\n");
238                 return err;
239         }
240
241         return 0;
242 }
243
244 static int shutdown_event(struct notifier_block *notifier,
245                           unsigned long event,
246                           void *data)
247 {
248         setup_shutdown_watcher();
249         return NOTIFY_DONE;
250 }
251
252 static int __init setup_shutdown_event(void)
253 {
254         static struct notifier_block xenstore_notifier = {
255                 .notifier_call = shutdown_event
256         };
257         register_xenstore_notifier(&xenstore_notifier);
258
259         return 0;
260 }
261
262 subsys_initcall(setup_shutdown_event);