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 28 enum 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. */ 40 static enum shutdown_state shutting_down = SHUTDOWN_INVALID; 41 42 struct suspend_info { 43 int cancelled; 44 }; 45 46 static RAW_NOTIFIER_HEAD(xen_resume_notifier); 47 48 void xen_resume_notifier_register(struct notifier_block *nb) 49 { 50 raw_notifier_chain_register(&xen_resume_notifier, nb); 51 } 52 EXPORT_SYMBOL_GPL(xen_resume_notifier_register); 53 54 void xen_resume_notifier_unregister(struct notifier_block *nb) 55 { 56 raw_notifier_chain_unregister(&xen_resume_notifier, nb); 57 } 58 EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister); 59 60 #ifdef CONFIG_HIBERNATE_CALLBACKS 61 static 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 99 static 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 155 out_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 163 out_thaw: 164 thaw_processes(); 165 out: 166 shutting_down = SHUTDOWN_INVALID; 167 } 168 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 169 170 struct shutdown_handler { 171 #define SHUTDOWN_CMD_SIZE 11 172 const char command[SHUTDOWN_CMD_SIZE]; 173 bool flag; 174 void (*cb)(void); 175 }; 176 177 static 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 } 189 static void do_poweroff(void) 190 { 191 switch (system_state) { 192 case SYSTEM_BOOTING: 193 case SYSTEM_SCHEDULING: 194 orderly_poweroff(true); 195 break; 196 case SYSTEM_RUNNING: 197 orderly_poweroff(false); 198 break; 199 default: 200 /* Don't do it when we are halting/rebooting. */ 201 pr_info("Ignoring Xen toolstack shutdown.\n"); 202 break; 203 } 204 } 205 206 static void do_reboot(void) 207 { 208 shutting_down = SHUTDOWN_POWEROFF; /* ? */ 209 ctrl_alt_del(); 210 } 211 212 static struct shutdown_handler shutdown_handlers[] = { 213 { "poweroff", true, do_poweroff }, 214 { "halt", false, do_poweroff }, 215 { "reboot", true, do_reboot }, 216 #ifdef CONFIG_HIBERNATE_CALLBACKS 217 { "suspend", true, do_suspend }, 218 #endif 219 }; 220 221 static void shutdown_handler(struct xenbus_watch *watch, 222 const char *path, const char *token) 223 { 224 char *str; 225 struct xenbus_transaction xbt; 226 int err; 227 int idx; 228 229 if (shutting_down != SHUTDOWN_INVALID) 230 return; 231 232 again: 233 err = xenbus_transaction_start(&xbt); 234 if (err) 235 return; 236 237 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL); 238 /* Ignore read errors and empty reads. */ 239 if (XENBUS_IS_ERR_READ(str)) { 240 xenbus_transaction_end(xbt, 1); 241 return; 242 } 243 244 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) { 245 if (strcmp(str, shutdown_handlers[idx].command) == 0) 246 break; 247 } 248 249 /* Only acknowledge commands which we are prepared to handle. */ 250 if (idx < ARRAY_SIZE(shutdown_handlers)) 251 xenbus_write(xbt, "control", "shutdown", ""); 252 253 err = xenbus_transaction_end(xbt, 0); 254 if (err == -EAGAIN) { 255 kfree(str); 256 goto again; 257 } 258 259 if (idx < ARRAY_SIZE(shutdown_handlers)) { 260 shutdown_handlers[idx].cb(); 261 } else { 262 pr_info("Ignoring shutdown request: %s\n", str); 263 shutting_down = SHUTDOWN_INVALID; 264 } 265 266 kfree(str); 267 } 268 269 #ifdef CONFIG_MAGIC_SYSRQ 270 static void sysrq_handler(struct xenbus_watch *watch, const char *path, 271 const char *token) 272 { 273 char sysrq_key = '\0'; 274 struct xenbus_transaction xbt; 275 int err; 276 277 again: 278 err = xenbus_transaction_start(&xbt); 279 if (err) 280 return; 281 err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key); 282 if (err < 0) { 283 /* 284 * The Xenstore watch fires directly after registering it and 285 * after a suspend/resume cycle. So ENOENT is no error but 286 * might happen in those cases. 287 */ 288 if (err != -ENOENT) 289 pr_err("Error %d reading sysrq code in control/sysrq\n", 290 err); 291 xenbus_transaction_end(xbt, 1); 292 return; 293 } 294 295 if (sysrq_key != '\0') 296 xenbus_printf(xbt, "control", "sysrq", "%c", '\0'); 297 298 err = xenbus_transaction_end(xbt, 0); 299 if (err == -EAGAIN) 300 goto again; 301 302 if (sysrq_key != '\0') 303 handle_sysrq(sysrq_key); 304 } 305 306 static struct xenbus_watch sysrq_watch = { 307 .node = "control/sysrq", 308 .callback = sysrq_handler 309 }; 310 #endif 311 312 static struct xenbus_watch shutdown_watch = { 313 .node = "control/shutdown", 314 .callback = shutdown_handler 315 }; 316 317 static struct notifier_block xen_reboot_nb = { 318 .notifier_call = poweroff_nb, 319 }; 320 321 static int setup_shutdown_watcher(void) 322 { 323 int err; 324 int idx; 325 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-")) 326 char node[FEATURE_PATH_SIZE]; 327 328 err = register_xenbus_watch(&shutdown_watch); 329 if (err) { 330 pr_err("Failed to set shutdown watcher\n"); 331 return err; 332 } 333 334 335 #ifdef CONFIG_MAGIC_SYSRQ 336 err = register_xenbus_watch(&sysrq_watch); 337 if (err) { 338 pr_err("Failed to set sysrq watcher\n"); 339 return err; 340 } 341 #endif 342 343 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) { 344 if (!shutdown_handlers[idx].flag) 345 continue; 346 snprintf(node, FEATURE_PATH_SIZE, "feature-%s", 347 shutdown_handlers[idx].command); 348 xenbus_printf(XBT_NIL, "control", node, "%u", 1); 349 } 350 351 return 0; 352 } 353 354 static int shutdown_event(struct notifier_block *notifier, 355 unsigned long event, 356 void *data) 357 { 358 setup_shutdown_watcher(); 359 return NOTIFY_DONE; 360 } 361 362 int xen_setup_shutdown_event(void) 363 { 364 static struct notifier_block xenstore_notifier = { 365 .notifier_call = shutdown_event 366 }; 367 368 if (!xen_domain()) 369 return -ENODEV; 370 register_xenstore_notifier(&xenstore_notifier); 371 register_reboot_notifier(&xen_reboot_nb); 372 373 return 0; 374 } 375 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); 376 377 subsys_initcall(xen_setup_shutdown_event); 378