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