Merge git://git.kernel.org/pub/scm/linux/kernel/git/hskinnemoen/avr32-2.6
[linux-2.6] / 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 = 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         }
48         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         }
55
56         xen_mm_pin_all();
57         gnttab_suspend();
58         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);
68         gnttab_resume();
69         xen_mm_unpin_all();
70
71         sysdev_resume();
72         device_power_up(PMSG_RESUME);
73
74         if (!*cancelled) {
75                 xen_irq_resume();
76                 xen_console_resume();
77                 xen_timer_resume();
78         }
79
80         return 0;
81 }
82
83 static 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
111         err = stop_machine(xen_suspend, &cancelled, &cpumask_of_cpu(0));
112         if (err) {
113                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
114                 goto out;
115         }
116
117         if (!cancelled) {
118                 xen_arch_resume();
119                 xenbus_resume();
120         } else
121                 xenbus_suspend_cancel();
122
123         device_resume(PMSG_RESUME);
124
125         /* Make sure timer events get retriggered on all CPUs */
126         clock_was_set();
127 out:
128 #ifdef CONFIG_PREEMPT
129         thaw_processes();
130 #endif
131         shutting_down = SHUTDOWN_INVALID;
132 }
133 #endif  /* CONFIG_PM_SLEEP */
134
135 static 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 ||
166             strcmp(str, "halt") == 0) {
167                 shutting_down = SHUTDOWN_POWEROFF;
168                 orderly_poweroff(false);
169         } else if (strcmp(str, "reboot") == 0) {
170                 shutting_down = SHUTDOWN_POWEROFF; /* ? */
171                 ctrl_alt_del();
172 #ifdef CONFIG_PM_SLEEP
173         } else if (strcmp(str, "suspend") == 0) {
174                 do_suspend();
175 #endif
176         } else {
177                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
178                 shutting_down = SHUTDOWN_INVALID;
179         }
180
181         kfree(str);
182 }
183
184 static 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
213 static struct xenbus_watch shutdown_watch = {
214         .node = "control/shutdown",
215         .callback = shutdown_handler
216 };
217
218 static struct xenbus_watch sysrq_watch = {
219         .node = "control/sysrq",
220         .callback = sysrq_handler
221 };
222
223 static 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
242 static 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
250 static 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
260 subsys_initcall(setup_shutdown_event);