Thomas Gleixner | 457c899 | 2019-05-19 13:08:55 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Handle extern requests for shutdown, reboot and sysrq |
| 4 | */ |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 5 | |
| 6 | #define pr_fmt(fmt) "xen:" KBUILD_MODNAME ": " fmt |
| 7 | |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 8 | #include <linux/kernel.h> |
| 9 | #include <linux/err.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 10 | #include <linux/slab.h> |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 11 | #include <linux/reboot.h> |
| 12 | #include <linux/sysrq.h> |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 13 | #include <linux/stop_machine.h> |
| 14 | #include <linux/freezer.h> |
Rafael J. Wysocki | 19234c0 | 2011-04-20 00:36:11 +0200 | [diff] [blame] | 15 | #include <linux/syscore_ops.h> |
Paul Gortmaker | 63c9744 | 2011-07-10 13:22:07 -0400 | [diff] [blame] | 16 | #include <linux/export.h> |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 17 | |
Stefano Stabellini | 016b6f5 | 2010-05-14 12:45:07 +0100 | [diff] [blame] | 18 | #include <xen/xen.h> |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 19 | #include <xen/xenbus.h> |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 20 | #include <xen/grant_table.h> |
| 21 | #include <xen/events.h> |
| 22 | #include <xen/hvc-console.h> |
Julien Grall | a9fd60e | 2015-06-17 15:28:02 +0100 | [diff] [blame] | 23 | #include <xen/page.h> |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 24 | #include <xen/xen-ops.h> |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 25 | |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 26 | #include <asm/xen/hypercall.h> |
Stefano Stabellini | 016b6f5 | 2010-05-14 12:45:07 +0100 | [diff] [blame] | 27 | #include <asm/xen/hypervisor.h> |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 28 | |
| 29 | enum 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 Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 39 | |
| 40 | /* Ignore multiple shutdown requests. */ |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 41 | static enum shutdown_state shutting_down = SHUTDOWN_INVALID; |
| 42 | |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 43 | struct suspend_info { |
| 44 | int cancelled; |
| 45 | }; |
| 46 | |
Stanislaw Gruszka | cd97988 | 2014-02-26 11:30:30 +0100 | [diff] [blame] | 47 | static RAW_NOTIFIER_HEAD(xen_resume_notifier); |
| 48 | |
| 49 | void xen_resume_notifier_register(struct notifier_block *nb) |
| 50 | { |
| 51 | raw_notifier_chain_register(&xen_resume_notifier, nb); |
| 52 | } |
| 53 | EXPORT_SYMBOL_GPL(xen_resume_notifier_register); |
| 54 | |
| 55 | void xen_resume_notifier_unregister(struct notifier_block *nb) |
| 56 | { |
| 57 | raw_notifier_chain_unregister(&xen_resume_notifier, nb); |
| 58 | } |
| 59 | EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister); |
| 60 | |
Stefano Stabellini | 65e053a | 2013-06-27 14:28:38 +0100 | [diff] [blame] | 61 | #ifdef CONFIG_HIBERNATE_CALLBACKS |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 62 | static int xen_suspend(void *data) |
| 63 | { |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 64 | struct suspend_info *si = data; |
Jeremy Fitzhardinge | 359cdd3 | 2008-05-26 23:31:28 +0100 | [diff] [blame] | 65 | int err; |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 66 | |
| 67 | BUG_ON(!irqs_disabled()); |
| 68 | |
Rafael J. Wysocki | 2e711c0 | 2011-04-26 19:15:07 +0200 | [diff] [blame] | 69 | err = syscore_suspend(); |
Rafael J. Wysocki | 770824b | 2009-02-22 18:38:50 +0100 | [diff] [blame] | 70 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 71 | pr_err("%s: system core suspend failed: %d\n", __func__, err); |
Rafael J. Wysocki | 770824b | 2009-02-22 18:38:50 +0100 | [diff] [blame] | 72 | return err; |
| 73 | } |
Jeremy Fitzhardinge | 359cdd3 | 2008-05-26 23:31:28 +0100 | [diff] [blame] | 74 | |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 75 | gnttab_suspend(); |
Dongli Zhang | 5e25f5d | 2017-11-01 09:46:33 +0800 | [diff] [blame] | 76 | xen_manage_runstate_time(-1); |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 77 | xen_arch_pre_suspend(); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 78 | |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 79 | si->cancelled = HYPERVISOR_suspend(xen_pv_domain() |
Julien Grall | 0df4f26 | 2015-08-07 17:34:37 +0100 | [diff] [blame] | 80 | ? virt_to_gfn(xen_start_info) |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 81 | : 0); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 82 | |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 83 | xen_arch_post_suspend(si->cancelled); |
Dongli Zhang | 5e25f5d | 2017-11-01 09:46:33 +0800 | [diff] [blame] | 84 | xen_manage_runstate_time(si->cancelled ? 1 : 0); |
David Vrabel | aa8532c | 2014-05-08 11:09:23 +0100 | [diff] [blame] | 85 | gnttab_resume(); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 86 | |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 87 | if (!si->cancelled) { |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 88 | xen_irq_resume(); |
Isaku Yamahata | ad55db9 | 2008-07-08 15:06:32 -0700 | [diff] [blame] | 89 | xen_timer_resume(); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 90 | } |
| 91 | |
Rafael J. Wysocki | 19234c0 | 2011-04-20 00:36:11 +0200 | [diff] [blame] | 92 | syscore_resume(); |
Ian Campbell | 1e6fcf8 | 2009-03-25 17:46:42 +0000 | [diff] [blame] | 93 | |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 94 | return 0; |
| 95 | } |
| 96 | |
| 97 | static void do_suspend(void) |
| 98 | { |
| 99 | int err; |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 100 | struct suspend_info si; |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 101 | |
| 102 | shutting_down = SHUTDOWN_SUSPEND; |
| 103 | |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 104 | err = freeze_processes(); |
| 105 | if (err) { |
Ross Lagerwall | 72978b2 | 2015-01-19 13:19:38 +0000 | [diff] [blame] | 106 | pr_err("%s: freeze processes failed %d\n", __func__, err); |
Tejun Heo | 3fc1f1e | 2010-05-06 18:49:20 +0200 | [diff] [blame] | 107 | goto out; |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 108 | } |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 109 | |
Ross Lagerwall | 72978b2 | 2015-01-19 13:19:38 +0000 | [diff] [blame] | 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 | |
Shriram Rajagopalan | b3e96c0 | 2011-02-22 14:59:06 -0800 | [diff] [blame] | 116 | err = dpm_suspend_start(PMSG_FREEZE); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 117 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 118 | pr_err("%s: dpm_suspend_start %d\n", __func__, err); |
Ian Campbell | 65f6338 | 2009-12-01 11:47:14 +0000 | [diff] [blame] | 119 | goto out_thaw; |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 120 | } |
| 121 | |
Ian Campbell | c5cae66 | 2009-12-17 13:57:09 +0000 | [diff] [blame] | 122 | printk(KERN_DEBUG "suspending xenstore...\n"); |
| 123 | xs_suspend(); |
| 124 | |
Rafael J. Wysocki | cf579df | 2012-01-29 20:38:29 +0100 | [diff] [blame] | 125 | err = dpm_suspend_end(PMSG_FREEZE); |
Rafael J. Wysocki | 2ed8d2b | 2009-03-16 22:34:06 +0100 | [diff] [blame] | 126 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 127 | pr_err("dpm_suspend_end failed: %d\n", err); |
Konrad Rzeszutek Wilk | 186bab1 | 2012-04-17 14:35:49 -0400 | [diff] [blame] | 128 | si.cancelled = 0; |
Ian Campbell | 65f6338 | 2009-12-01 11:47:14 +0000 | [diff] [blame] | 129 | goto out_resume; |
Rafael J. Wysocki | 2ed8d2b | 2009-03-16 22:34:06 +0100 | [diff] [blame] | 130 | } |
| 131 | |
Boris Ostrovsky | 2b953a5 | 2015-04-28 18:46:20 -0400 | [diff] [blame] | 132 | xen_arch_suspend(); |
| 133 | |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 134 | si.cancelled = 1; |
| 135 | |
Ian Campbell | b056b6a | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 136 | err = stop_machine(xen_suspend, &si, cpumask_of(0)); |
Jeremy Fitzhardinge | 922cc38a | 2009-11-24 09:58:49 -0800 | [diff] [blame] | 137 | |
David Vrabel | 1b64782 | 2014-07-02 17:25:23 +0100 | [diff] [blame] | 138 | /* Resume console as early as possible. */ |
| 139 | if (!si.cancelled) |
| 140 | xen_console_resume(); |
| 141 | |
Stanislaw Gruszka | cd97988 | 2014-02-26 11:30:30 +0100 | [diff] [blame] | 142 | raw_notifier_call_chain(&xen_resume_notifier, 0, NULL); |
| 143 | |
Rafael J. Wysocki | cf579df | 2012-01-29 20:38:29 +0100 | [diff] [blame] | 144 | dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE); |
Jeremy Fitzhardinge | 922cc38a | 2009-11-24 09:58:49 -0800 | [diff] [blame] | 145 | |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 146 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 147 | pr_err("failed to start xen_suspend: %d\n", err); |
Ian Campbell | ceb1802 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 148 | si.cancelled = 1; |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 149 | } |
| 150 | |
Boris Ostrovsky | 2b953a5 | 2015-04-28 18:46:20 -0400 | [diff] [blame] | 151 | xen_arch_resume(); |
| 152 | |
Ian Campbell | c5cae66 | 2009-12-17 13:57:09 +0000 | [diff] [blame] | 153 | out_resume: |
Boris Ostrovsky | 2b953a5 | 2015-04-28 18:46:20 -0400 | [diff] [blame] | 154 | if (!si.cancelled) |
Ian Campbell | de5b31b | 2009-02-09 12:05:50 -0800 | [diff] [blame] | 155 | xs_resume(); |
Boris Ostrovsky | 2b953a5 | 2015-04-28 18:46:20 -0400 | [diff] [blame] | 156 | else |
Ian Campbell | de5b31b | 2009-02-09 12:05:50 -0800 | [diff] [blame] | 157 | xs_suspend_cancel(); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 158 | |
Shriram Rajagopalan | b3e96c0 | 2011-02-22 14:59:06 -0800 | [diff] [blame] | 159 | dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 160 | |
Ian Campbell | 65f6338 | 2009-12-01 11:47:14 +0000 | [diff] [blame] | 161 | out_thaw: |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 162 | thaw_processes(); |
Ian Campbell | 65f6338 | 2009-12-01 11:47:14 +0000 | [diff] [blame] | 163 | out: |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 164 | shutting_down = SHUTDOWN_INVALID; |
| 165 | } |
Rafael J. Wysocki | 1f112ce | 2011-04-11 22:54:42 +0200 | [diff] [blame] | 166 | #endif /* CONFIG_HIBERNATE_CALLBACKS */ |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 167 | |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 168 | struct shutdown_handler { |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 169 | #define SHUTDOWN_CMD_SIZE 11 |
| 170 | const char command[SHUTDOWN_CMD_SIZE]; |
| 171 | bool flag; |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 172 | void (*cb)(void); |
| 173 | }; |
| 174 | |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 175 | static 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. Silva | 5e65f524 | 2020-11-20 12:40:55 -0600 | [diff] [blame] | 182 | break; |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 183 | default: |
| 184 | break; |
| 185 | } |
| 186 | return NOTIFY_DONE; |
| 187 | } |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 188 | static void do_poweroff(void) |
| 189 | { |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 190 | switch (system_state) { |
| 191 | case SYSTEM_BOOTING: |
Thomas Gleixner | 69a78ff | 2017-05-16 20:42:47 +0200 | [diff] [blame] | 192 | case SYSTEM_SCHEDULING: |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 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 | } |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 203 | } |
| 204 | |
| 205 | static void do_reboot(void) |
| 206 | { |
| 207 | shutting_down = SHUTDOWN_POWEROFF; /* ? */ |
| 208 | ctrl_alt_del(); |
| 209 | } |
| 210 | |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 211 | static 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 Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 220 | static void shutdown_handler(struct xenbus_watch *watch, |
Juergen Gross | 5584ea2 | 2017-02-09 14:39:57 +0100 | [diff] [blame] | 221 | const char *path, const char *token) |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 222 | { |
| 223 | char *str; |
| 224 | struct xenbus_transaction xbt; |
| 225 | int err; |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 226 | int idx; |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 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 | |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 243 | for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) { |
| 244 | if (strcmp(str, shutdown_handlers[idx].command) == 0) |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 245 | break; |
| 246 | } |
| 247 | |
| 248 | /* Only acknowledge commands which we are prepared to handle. */ |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 249 | if (idx < ARRAY_SIZE(shutdown_handlers)) |
Ian Campbell | 5527172 | 2011-02-17 11:04:20 +0000 | [diff] [blame] | 250 | xenbus_write(xbt, "control", "shutdown", ""); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 251 | |
| 252 | err = xenbus_transaction_end(xbt, 0); |
| 253 | if (err == -EAGAIN) { |
| 254 | kfree(str); |
| 255 | goto again; |
| 256 | } |
| 257 | |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 258 | if (idx < ARRAY_SIZE(shutdown_handlers)) { |
| 259 | shutdown_handlers[idx].cb(); |
Jeremy Fitzhardinge | 0e91398 | 2008-05-26 23:31:27 +0100 | [diff] [blame] | 260 | } else { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 261 | pr_info("Ignoring shutdown request: %s\n", str); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 262 | shutting_down = SHUTDOWN_INVALID; |
| 263 | } |
| 264 | |
| 265 | kfree(str); |
| 266 | } |
| 267 | |
Randy Dunlap | f3bc318 | 2010-05-24 14:33:41 -0700 | [diff] [blame] | 268 | #ifdef CONFIG_MAGIC_SYSRQ |
Juergen Gross | 5584ea2 | 2017-02-09 14:39:57 +0100 | [diff] [blame] | 269 | static void sysrq_handler(struct xenbus_watch *watch, const char *path, |
| 270 | const char *token) |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 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; |
Juergen Gross | 4e93b648 | 2017-05-30 20:52:26 +0200 | [diff] [blame] | 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 |
Vitaly Kuznetsov | 87dffe8 | 2018-09-06 13:26:08 +0200 | [diff] [blame] | 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. |
Juergen Gross | 4e93b648 | 2017-05-30 20:52:26 +0200 | [diff] [blame] | 288 | */ |
Vitaly Kuznetsov | 87dffe8 | 2018-09-06 13:26:08 +0200 | [diff] [blame] | 289 | if (err != -ENOENT && err != -ERANGE) |
Juergen Gross | 4e93b648 | 2017-05-30 20:52:26 +0200 | [diff] [blame] | 290 | pr_err("Error %d reading sysrq code in control/sysrq\n", |
| 291 | err); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 292 | xenbus_transaction_end(xbt, 1); |
| 293 | return; |
| 294 | } |
| 295 | |
Zhouyang Jia | 84c029a | 2018-06-15 07:34:52 +0800 | [diff] [blame] | 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 | } |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 305 | |
| 306 | err = xenbus_transaction_end(xbt, 0); |
| 307 | if (err == -EAGAIN) |
| 308 | goto again; |
| 309 | |
| 310 | if (sysrq_key != '\0') |
Dmitry Torokhov | f335397 | 2010-08-17 21:15:47 -0700 | [diff] [blame] | 311 | handle_sysrq(sysrq_key); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 312 | } |
| 313 | |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 314 | static struct xenbus_watch sysrq_watch = { |
| 315 | .node = "control/sysrq", |
| 316 | .callback = sysrq_handler |
| 317 | }; |
Randy Dunlap | f3bc318 | 2010-05-24 14:33:41 -0700 | [diff] [blame] | 318 | #endif |
| 319 | |
| 320 | static struct xenbus_watch shutdown_watch = { |
| 321 | .node = "control/shutdown", |
| 322 | .callback = shutdown_handler |
| 323 | }; |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 324 | |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 325 | static struct notifier_block xen_reboot_nb = { |
| 326 | .notifier_call = poweroff_nb, |
| 327 | }; |
| 328 | |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 329 | static int setup_shutdown_watcher(void) |
| 330 | { |
| 331 | int err; |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 332 | int idx; |
| 333 | #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-")) |
| 334 | char node[FEATURE_PATH_SIZE]; |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 335 | |
| 336 | err = register_xenbus_watch(&shutdown_watch); |
| 337 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 338 | pr_err("Failed to set shutdown watcher\n"); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 339 | return err; |
| 340 | } |
| 341 | |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 342 | |
Randy Dunlap | f3bc318 | 2010-05-24 14:33:41 -0700 | [diff] [blame] | 343 | #ifdef CONFIG_MAGIC_SYSRQ |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 344 | err = register_xenbus_watch(&sysrq_watch); |
| 345 | if (err) { |
Joe Perches | 283c097 | 2013-06-28 03:21:41 -0700 | [diff] [blame] | 346 | pr_err("Failed to set sysrq watcher\n"); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 347 | return err; |
| 348 | } |
Randy Dunlap | f3bc318 | 2010-05-24 14:33:41 -0700 | [diff] [blame] | 349 | #endif |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 350 | |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 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); |
Zhouyang Jia | 84c029a | 2018-06-15 07:34:52 +0800 | [diff] [blame] | 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 | } |
Juergen Gross | 44b3c7a | 2016-10-11 13:34:16 +0200 | [diff] [blame] | 362 | } |
| 363 | |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 364 | return 0; |
| 365 | } |
| 366 | |
| 367 | static 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 Stabellini | 016b6f5 | 2010-05-14 12:45:07 +0100 | [diff] [blame] | 375 | int xen_setup_shutdown_event(void) |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 376 | { |
| 377 | static struct notifier_block xenstore_notifier = { |
| 378 | .notifier_call = shutdown_event |
| 379 | }; |
Stefano Stabellini | 702d4eb9 | 2010-12-02 17:54:50 +0000 | [diff] [blame] | 380 | |
| 381 | if (!xen_domain()) |
| 382 | return -ENODEV; |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 383 | register_xenstore_notifier(&xenstore_notifier); |
Konrad Rzeszutek Wilk | eb47f71 | 2014-04-04 14:53:41 -0400 | [diff] [blame] | 384 | register_reboot_notifier(&xen_reboot_nb); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 385 | |
| 386 | return 0; |
| 387 | } |
Stefano Stabellini | 183d03c | 2010-05-17 17:08:21 +0100 | [diff] [blame] | 388 | EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); |
Jeremy Fitzhardinge | 3e2b8fb | 2007-07-17 18:37:07 -0700 | [diff] [blame] | 389 | |
Stefano Stabellini | 702d4eb9 | 2010-12-02 17:54:50 +0000 | [diff] [blame] | 390 | subsys_initcall(xen_setup_shutdown_event); |