PM / Hibernate: Introduce CONFIG_HIBERNATE_CALLBACKS
[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 struct suspend_info {
38         int cancelled;
39         unsigned long arg; /* extra hypercall argument */
40         void (*pre)(void);
41         void (*post)(int cancelled);
42 };
43
44 static void xen_hvm_post_suspend(int cancelled)
45 {
46         xen_arch_hvm_post_suspend(cancelled);
47         gnttab_resume();
48 }
49
50 static void xen_pre_suspend(void)
51 {
52         xen_mm_pin_all();
53         gnttab_suspend();
54         xen_arch_pre_suspend();
55 }
56
57 static void xen_post_suspend(int cancelled)
58 {
59         xen_arch_post_suspend(cancelled);
60         gnttab_resume();
61         xen_mm_unpin_all();
62 }
63
64 #ifdef CONFIG_HIBERNATE_CALLBACKS
65 static int xen_suspend(void *data)
66 {
67         struct suspend_info *si = data;
68         int err;
69
70         BUG_ON(!irqs_disabled());
71
72         err = sysdev_suspend(PMSG_FREEZE);
73         if (err) {
74                 printk(KERN_ERR "xen_suspend: sysdev_suspend failed: %d\n",
75                         err);
76                 return err;
77         }
78
79         if (si->pre)
80                 si->pre();
81
82         /*
83          * This hypercall returns 1 if suspend was cancelled
84          * or the domain was merely checkpointed, and 0 if it
85          * is resuming in a new domain.
86          */
87         si->cancelled = HYPERVISOR_suspend(si->arg);
88
89         if (si->post)
90                 si->post(si->cancelled);
91
92         if (!si->cancelled) {
93                 xen_irq_resume();
94                 xen_console_resume();
95                 xen_timer_resume();
96         }
97
98         sysdev_resume();
99
100         return 0;
101 }
102
103 static void do_suspend(void)
104 {
105         int err;
106         struct suspend_info si;
107
108         shutting_down = SHUTDOWN_SUSPEND;
109
110 #ifdef CONFIG_PREEMPT
111         /* If the kernel is preemptible, we need to freeze all the processes
112            to prevent them from being in the middle of a pagetable update
113            during suspend. */
114         err = freeze_processes();
115         if (err) {
116                 printk(KERN_ERR "xen suspend: freeze failed %d\n", err);
117                 goto out;
118         }
119 #endif
120
121         err = dpm_suspend_start(PMSG_FREEZE);
122         if (err) {
123                 printk(KERN_ERR "xen suspend: dpm_suspend_start %d\n", err);
124                 goto out_thaw;
125         }
126
127         printk(KERN_DEBUG "suspending xenstore...\n");
128         xs_suspend();
129
130         err = dpm_suspend_noirq(PMSG_FREEZE);
131         if (err) {
132                 printk(KERN_ERR "dpm_suspend_noirq failed: %d\n", err);
133                 goto out_resume;
134         }
135
136         si.cancelled = 1;
137
138         if (xen_hvm_domain()) {
139                 si.arg = 0UL;
140                 si.pre = NULL;
141                 si.post = &xen_hvm_post_suspend;
142         } else {
143                 si.arg = virt_to_mfn(xen_start_info);
144                 si.pre = &xen_pre_suspend;
145                 si.post = &xen_post_suspend;
146         }
147
148         err = stop_machine(xen_suspend, &si, cpumask_of(0));
149
150         dpm_resume_noirq(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
151
152         if (err) {
153                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
154                 si.cancelled = 1;
155         }
156
157 out_resume:
158         if (!si.cancelled) {
159                 xen_arch_resume();
160                 xs_resume();
161         } else
162                 xs_suspend_cancel();
163
164         dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
165
166         /* Make sure timer events get retriggered on all CPUs */
167         clock_was_set();
168
169 out_thaw:
170 #ifdef CONFIG_PREEMPT
171         thaw_processes();
172 out:
173 #endif
174         shutting_down = SHUTDOWN_INVALID;
175 }
176 #endif  /* CONFIG_HIBERNATE_CALLBACKS */
177
178 struct shutdown_handler {
179         const char *command;
180         void (*cb)(void);
181 };
182
183 static void do_poweroff(void)
184 {
185         shutting_down = SHUTDOWN_POWEROFF;
186         orderly_poweroff(false);
187 }
188
189 static void do_reboot(void)
190 {
191         shutting_down = SHUTDOWN_POWEROFF; /* ? */
192         ctrl_alt_del();
193 }
194
195 static void shutdown_handler(struct xenbus_watch *watch,
196                              const char **vec, unsigned int len)
197 {
198         char *str;
199         struct xenbus_transaction xbt;
200         int err;
201         static struct shutdown_handler handlers[] = {
202                 { "poweroff",   do_poweroff },
203                 { "halt",       do_poweroff },
204                 { "reboot",     do_reboot   },
205 #ifdef CONFIG_HIBERNATE_CALLBACKS
206                 { "suspend",    do_suspend  },
207 #endif
208                 {NULL, NULL},
209         };
210         static struct shutdown_handler *handler;
211
212         if (shutting_down != SHUTDOWN_INVALID)
213                 return;
214
215  again:
216         err = xenbus_transaction_start(&xbt);
217         if (err)
218                 return;
219
220         str = (char *)xenbus_read(xbt, "control", "shutdown", NULL);
221         /* Ignore read errors and empty reads. */
222         if (XENBUS_IS_ERR_READ(str)) {
223                 xenbus_transaction_end(xbt, 1);
224                 return;
225         }
226
227         for (handler = &handlers[0]; handler->command; handler++) {
228                 if (strcmp(str, handler->command) == 0)
229                         break;
230         }
231
232         /* Only acknowledge commands which we are prepared to handle. */
233         if (handler->cb)
234                 xenbus_write(xbt, "control", "shutdown", "");
235
236         err = xenbus_transaction_end(xbt, 0);
237         if (err == -EAGAIN) {
238                 kfree(str);
239                 goto again;
240         }
241
242         if (handler->cb) {
243                 handler->cb();
244         } else {
245                 printk(KERN_INFO "Ignoring shutdown request: %s\n", str);
246                 shutting_down = SHUTDOWN_INVALID;
247         }
248
249         kfree(str);
250 }
251
252 #ifdef CONFIG_MAGIC_SYSRQ
253 static void sysrq_handler(struct xenbus_watch *watch, const char **vec,
254                           unsigned int len)
255 {
256         char sysrq_key = '\0';
257         struct xenbus_transaction xbt;
258         int err;
259
260  again:
261         err = xenbus_transaction_start(&xbt);
262         if (err)
263                 return;
264         if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) {
265                 printk(KERN_ERR "Unable to read sysrq code in "
266                        "control/sysrq\n");
267                 xenbus_transaction_end(xbt, 1);
268                 return;
269         }
270
271         if (sysrq_key != '\0')
272                 xenbus_printf(xbt, "control", "sysrq", "%c", '\0');
273
274         err = xenbus_transaction_end(xbt, 0);
275         if (err == -EAGAIN)
276                 goto again;
277
278         if (sysrq_key != '\0')
279                 handle_sysrq(sysrq_key);
280 }
281
282 static struct xenbus_watch sysrq_watch = {
283         .node = "control/sysrq",
284         .callback = sysrq_handler
285 };
286 #endif
287
288 static struct xenbus_watch shutdown_watch = {
289         .node = "control/shutdown",
290         .callback = shutdown_handler
291 };
292
293 static int setup_shutdown_watcher(void)
294 {
295         int err;
296
297         err = register_xenbus_watch(&shutdown_watch);
298         if (err) {
299                 printk(KERN_ERR "Failed to set shutdown watcher\n");
300                 return err;
301         }
302
303 #ifdef CONFIG_MAGIC_SYSRQ
304         err = register_xenbus_watch(&sysrq_watch);
305         if (err) {
306                 printk(KERN_ERR "Failed to set sysrq watcher\n");
307                 return err;
308         }
309 #endif
310
311         return 0;
312 }
313
314 static int shutdown_event(struct notifier_block *notifier,
315                           unsigned long event,
316                           void *data)
317 {
318         setup_shutdown_watcher();
319         return NOTIFY_DONE;
320 }
321
322 int xen_setup_shutdown_event(void)
323 {
324         static struct notifier_block xenstore_notifier = {
325                 .notifier_call = shutdown_event
326         };
327
328         if (!xen_domain())
329                 return -ENODEV;
330         register_xenstore_notifier(&xenstore_notifier);
331
332         return 0;
333 }
334 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
335
336 subsys_initcall(xen_setup_shutdown_event);