blob: 374d36de7f5a45b698e39e506afa9ea6cd03be13 [file] [log] [blame]
Thomas Gleixner457c8992019-05-19 13:08:55 +01001// SPDX-License-Identifier: GPL-2.0-only
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -07002/*
3 * Handle extern requests for shutdown, reboot and sysrq
4 */
Joe Perches283c0972013-06-28 03:21:41 -07005
6#define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt
7
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -07008#include <linux/kernel.h>
9#include <linux/err.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070011#include <linux/reboot.h>
12#include <linux/sysrq.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010013#include <linux/stop_machine.h>
14#include <linux/freezer.h>
Rafael J. Wysocki19234c02011-04-20 00:36:11 +020015#include <linux/syscore_ops.h>
Paul Gortmaker63c97442011-07-10 13:22:07 -040016#include <linux/export.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070017
Stefano Stabellini016b6f52010-05-14 12:45:07 +010018#include <xen/xen.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070019#include <xen/xenbus.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010020#include <xen/grant_table.h>
21#include <xen/events.h>
22#include <xen/hvc-console.h>
Julien Gralla9fd60e2015-06-17 15:28:02 +010023#include <xen/page.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010024#include <xen/xen-ops.h>
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070025
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010026#include <asm/xen/hypercall.h>
Stefano Stabellini016b6f52010-05-14 12:45:07 +010027#include <asm/xen/hypervisor.h>
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010028
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};
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -070039
40/* Ignore multiple shutdown requests. */
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010041static enum shutdown_state shutting_down = SHUTDOWN_INVALID;
42
Ian Campbellceb18022011-02-17 11:04:20 +000043struct suspend_info {
44 int cancelled;
45};
46
Stanislaw Gruszkacd979882014-02-26 11:30:30 +010047static 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
Stefano Stabellini65e053a2013-06-27 14:28:38 +010061#ifdef CONFIG_HIBERNATE_CALLBACKS
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010062static int xen_suspend(void *data)
63{
Ian Campbellceb18022011-02-17 11:04:20 +000064 struct suspend_info *si = data;
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010065 int err;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010066
67 BUG_ON(!irqs_disabled());
68
Rafael J. Wysocki2e711c02011-04-26 19:15:07 +020069 err = syscore_suspend();
Rafael J. Wysocki770824b2009-02-22 18:38:50 +010070 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -070071 pr_err("%s: system core suspend failed: %d\n", __func__, err);
Rafael J. Wysocki770824b2009-02-22 18:38:50 +010072 return err;
73 }
Jeremy Fitzhardinge359cdd32008-05-26 23:31:28 +010074
David Vrabelaa8532c2014-05-08 11:09:23 +010075 gnttab_suspend();
Dongli Zhang5e25f5d2017-11-01 09:46:33 +080076 xen_manage_runstate_time(-1);
David Vrabelaa8532c2014-05-08 11:09:23 +010077 xen_arch_pre_suspend();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010078
David Vrabelaa8532c2014-05-08 11:09:23 +010079 si->cancelled = HYPERVISOR_suspend(xen_pv_domain()
Julien Grall0df4f262015-08-07 17:34:37 +010080 ? virt_to_gfn(xen_start_info)
David Vrabelaa8532c2014-05-08 11:09:23 +010081 : 0);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010082
David Vrabelaa8532c2014-05-08 11:09:23 +010083 xen_arch_post_suspend(si->cancelled);
Dongli Zhang5e25f5d2017-11-01 09:46:33 +080084 xen_manage_runstate_time(si->cancelled ? 1 : 0);
David Vrabelaa8532c2014-05-08 11:09:23 +010085 gnttab_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010086
Ian Campbellceb18022011-02-17 11:04:20 +000087 if (!si->cancelled) {
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010088 xen_irq_resume();
Isaku Yamahataad55db92008-07-08 15:06:32 -070089 xen_timer_resume();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010090 }
91
Rafael J. Wysocki19234c02011-04-20 00:36:11 +020092 syscore_resume();
Ian Campbell1e6fcf82009-03-25 17:46:42 +000093
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +010094 return 0;
95}
96
97static void do_suspend(void)
98{
99 int err;
Ian Campbellceb18022011-02-17 11:04:20 +0000100 struct suspend_info si;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100101
102 shutting_down = SHUTDOWN_SUSPEND;
103
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100104 err = freeze_processes();
105 if (err) {
Ross Lagerwall72978b22015-01-19 13:19:38 +0000106 pr_err("%s: freeze processes failed %d\n", __func__, err);
Tejun Heo3fc1f1e2010-05-06 18:49:20 +0200107 goto out;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100108 }
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100109
Ross Lagerwall72978b22015-01-19 13:19:38 +0000110 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
Shriram Rajagopalanb3e96c02011-02-22 14:59:06 -0800116 err = dpm_suspend_start(PMSG_FREEZE);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100117 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -0700118 pr_err("%s: dpm_suspend_start %d\n", __func__, err);
Ian Campbell65f63382009-12-01 11:47:14 +0000119 goto out_thaw;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100120 }
121
Ian Campbellc5cae662009-12-17 13:57:09 +0000122 printk(KERN_DEBUG "suspending xenstore...\n");
123 xs_suspend();
124
Rafael J. Wysockicf579df2012-01-29 20:38:29 +0100125 err = dpm_suspend_end(PMSG_FREEZE);
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100126 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -0700127 pr_err("dpm_suspend_end failed: %d\n", err);
Konrad Rzeszutek Wilk186bab12012-04-17 14:35:49 -0400128 si.cancelled = 0;
Ian Campbell65f63382009-12-01 11:47:14 +0000129 goto out_resume;
Rafael J. Wysocki2ed8d2b2009-03-16 22:34:06 +0100130 }
131
Boris Ostrovsky2b953a52015-04-28 18:46:20 -0400132 xen_arch_suspend();
133
Ian Campbellceb18022011-02-17 11:04:20 +0000134 si.cancelled = 1;
135
Ian Campbellb056b6a2011-02-17 11:04:20 +0000136 err = stop_machine(xen_suspend, &si, cpumask_of(0));
Jeremy Fitzhardinge922cc38a2009-11-24 09:58:49 -0800137
David Vrabel1b647822014-07-02 17:25:23 +0100138 /* Resume console as early as possible. */
139 if (!si.cancelled)
140 xen_console_resume();
141
Stanislaw Gruszkacd979882014-02-26 11:30:30 +0100142 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL);
143
Rafael J. Wysockicf579df2012-01-29 20:38:29 +0100144 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
Jeremy Fitzhardinge922cc38a2009-11-24 09:58:49 -0800145
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100146 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -0700147 pr_err("failed to start xen_suspend: %d\n", err);
Ian Campbellceb18022011-02-17 11:04:20 +0000148 si.cancelled = 1;
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100149 }
150
Boris Ostrovsky2b953a52015-04-28 18:46:20 -0400151 xen_arch_resume();
152
Ian Campbellc5cae662009-12-17 13:57:09 +0000153out_resume:
Boris Ostrovsky2b953a52015-04-28 18:46:20 -0400154 if (!si.cancelled)
Ian Campbellde5b31b2009-02-09 12:05:50 -0800155 xs_resume();
Boris Ostrovsky2b953a52015-04-28 18:46:20 -0400156 else
Ian Campbellde5b31b2009-02-09 12:05:50 -0800157 xs_suspend_cancel();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100158
Shriram Rajagopalanb3e96c02011-02-22 14:59:06 -0800159 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE);
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100160
Ian Campbell65f63382009-12-01 11:47:14 +0000161out_thaw:
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100162 thaw_processes();
Ian Campbell65f63382009-12-01 11:47:14 +0000163out:
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100164 shutting_down = SHUTDOWN_INVALID;
165}
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200166#endif /* CONFIG_HIBERNATE_CALLBACKS */
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700167
Ian Campbell55271722011-02-17 11:04:20 +0000168struct shutdown_handler {
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200169#define SHUTDOWN_CMD_SIZE 11
170 const char command[SHUTDOWN_CMD_SIZE];
171 bool flag;
Ian Campbell55271722011-02-17 11:04:20 +0000172 void (*cb)(void);
173};
174
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400175static 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;
Gustavo A. R. Silva5e65f5242020-11-20 12:40:55 -0600182 break;
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400183 default:
184 break;
185 }
186 return NOTIFY_DONE;
187}
Ian Campbell55271722011-02-17 11:04:20 +0000188static void do_poweroff(void)
189{
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400190 switch (system_state) {
191 case SYSTEM_BOOTING:
Thomas Gleixner69a78ff2017-05-16 20:42:47 +0200192 case SYSTEM_SCHEDULING:
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400193 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 }
Ian Campbell55271722011-02-17 11:04:20 +0000203}
204
205static void do_reboot(void)
206{
207 shutting_down = SHUTDOWN_POWEROFF; /* ? */
208 ctrl_alt_del();
209}
210
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200211static 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
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700220static void shutdown_handler(struct xenbus_watch *watch,
Juergen Gross5584ea22017-02-09 14:39:57 +0100221 const char *path, const char *token)
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700222{
223 char *str;
224 struct xenbus_transaction xbt;
225 int err;
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200226 int idx;
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700227
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
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200243 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) {
244 if (strcmp(str, shutdown_handlers[idx].command) == 0)
Ian Campbell55271722011-02-17 11:04:20 +0000245 break;
246 }
247
248 /* Only acknowledge commands which we are prepared to handle. */
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200249 if (idx < ARRAY_SIZE(shutdown_handlers))
Ian Campbell55271722011-02-17 11:04:20 +0000250 xenbus_write(xbt, "control", "shutdown", "");
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700251
252 err = xenbus_transaction_end(xbt, 0);
253 if (err == -EAGAIN) {
254 kfree(str);
255 goto again;
256 }
257
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200258 if (idx < ARRAY_SIZE(shutdown_handlers)) {
259 shutdown_handlers[idx].cb();
Jeremy Fitzhardinge0e913982008-05-26 23:31:27 +0100260 } else {
Joe Perches283c0972013-06-28 03:21:41 -0700261 pr_info("Ignoring shutdown request: %s\n", str);
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700262 shutting_down = SHUTDOWN_INVALID;
263 }
264
265 kfree(str);
266}
267
Randy Dunlapf3bc3182010-05-24 14:33:41 -0700268#ifdef CONFIG_MAGIC_SYSRQ
Juergen Gross5584ea22017-02-09 14:39:57 +0100269static void sysrq_handler(struct xenbus_watch *watch, const char *path,
270 const char *token)
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700271{
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;
Juergen Gross4e93b6482017-05-30 20:52:26 +0200280 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
Vitaly Kuznetsov87dffe82018-09-06 13:26:08 +0200285 * 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.
Juergen Gross4e93b6482017-05-30 20:52:26 +0200288 */
Vitaly Kuznetsov87dffe82018-09-06 13:26:08 +0200289 if (err != -ENOENT && err != -ERANGE)
Juergen Gross4e93b6482017-05-30 20:52:26 +0200290 pr_err("Error %d reading sysrq code in control/sysrq\n",
291 err);
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700292 xenbus_transaction_end(xbt, 1);
293 return;
294 }
295
Zhouyang Jia84c029a2018-06-15 07:34:52 +0800296 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 }
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700305
306 err = xenbus_transaction_end(xbt, 0);
307 if (err == -EAGAIN)
308 goto again;
309
310 if (sysrq_key != '\0')
Dmitry Torokhovf3353972010-08-17 21:15:47 -0700311 handle_sysrq(sysrq_key);
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700312}
313
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700314static struct xenbus_watch sysrq_watch = {
315 .node = "control/sysrq",
316 .callback = sysrq_handler
317};
Randy Dunlapf3bc3182010-05-24 14:33:41 -0700318#endif
319
320static struct xenbus_watch shutdown_watch = {
321 .node = "control/shutdown",
322 .callback = shutdown_handler
323};
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700324
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400325static struct notifier_block xen_reboot_nb = {
326 .notifier_call = poweroff_nb,
327};
328
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700329static int setup_shutdown_watcher(void)
330{
331 int err;
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200332 int idx;
333#define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-"))
334 char node[FEATURE_PATH_SIZE];
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700335
336 err = register_xenbus_watch(&shutdown_watch);
337 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -0700338 pr_err("Failed to set shutdown watcher\n");
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700339 return err;
340 }
341
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400342
Randy Dunlapf3bc3182010-05-24 14:33:41 -0700343#ifdef CONFIG_MAGIC_SYSRQ
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700344 err = register_xenbus_watch(&sysrq_watch);
345 if (err) {
Joe Perches283c0972013-06-28 03:21:41 -0700346 pr_err("Failed to set sysrq watcher\n");
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700347 return err;
348 }
Randy Dunlapf3bc3182010-05-24 14:33:41 -0700349#endif
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700350
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200351 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);
Zhouyang Jia84c029a2018-06-15 07:34:52 +0800356 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 }
Juergen Gross44b3c7a2016-10-11 13:34:16 +0200362 }
363
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700364 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
Stefano Stabellini016b6f52010-05-14 12:45:07 +0100375int xen_setup_shutdown_event(void)
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700376{
377 static struct notifier_block xenstore_notifier = {
378 .notifier_call = shutdown_event
379 };
Stefano Stabellini702d4eb92010-12-02 17:54:50 +0000380
381 if (!xen_domain())
382 return -ENODEV;
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700383 register_xenstore_notifier(&xenstore_notifier);
Konrad Rzeszutek Wilkeb47f712014-04-04 14:53:41 -0400384 register_reboot_notifier(&xen_reboot_nb);
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700385
386 return 0;
387}
Stefano Stabellini183d03c2010-05-17 17:08:21 +0100388EXPORT_SYMBOL_GPL(xen_setup_shutdown_event);
Jeremy Fitzhardinge3e2b8fb2007-07-17 18:37:07 -0700389
Stefano Stabellini702d4eb92010-12-02 17:54:50 +0000390subsys_initcall(xen_setup_shutdown_event);