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