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