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_manage_runstate_time(-1); 76 xen_arch_pre_suspend(); 77 78 si->cancelled = HYPERVISOR_suspend(xen_pv_domain() 79 ? virt_to_gfn(xen_start_info) 80 : 0); 81 82 xen_arch_post_suspend(si->cancelled); 83 xen_manage_runstate_time(si->cancelled ? 1 : 0); 84 gnttab_resume(); 85 86 if (!si->cancelled) { 87 xen_irq_resume(); 88 xen_timer_resume(); 89 } 90 91 syscore_resume(); 92 93 return 0; 94 } 95 96 static void do_suspend(void) 97 { 98 int err; 99 struct suspend_info si; 100 101 shutting_down = SHUTDOWN_SUSPEND; 102 103 err = freeze_processes(); 104 if (err) { 105 pr_err("%s: freeze processes failed %d\n", __func__, err); 106 goto out; 107 } 108 109 err = freeze_kernel_threads(); 110 if (err) { 111 pr_err("%s: freeze kernel threads failed %d\n", __func__, err); 112 goto out_thaw; 113 } 114 115 err = dpm_suspend_start(PMSG_FREEZE); 116 if (err) { 117 pr_err("%s: dpm_suspend_start %d\n", __func__, err); 118 goto out_thaw; 119 } 120 121 printk(KERN_DEBUG "suspending xenstore...\n"); 122 xs_suspend(); 123 124 err = dpm_suspend_end(PMSG_FREEZE); 125 if (err) { 126 pr_err("dpm_suspend_end failed: %d\n", err); 127 si.cancelled = 0; 128 goto out_resume; 129 } 130 131 xen_arch_suspend(); 132 133 si.cancelled = 1; 134 135 err = stop_machine(xen_suspend, &si, cpumask_of(0)); 136 137 /* Resume console as early as possible. */ 138 if (!si.cancelled) 139 xen_console_resume(); 140 141 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL); 142 143 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 144 145 if (err) { 146 pr_err("failed to start xen_suspend: %d\n", err); 147 si.cancelled = 1; 148 } 149 150 xen_arch_resume(); 151 152 out_resume: 153 if (!si.cancelled) 154 xs_resume(); 155 else 156 xs_suspend_cancel(); 157 158 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 159 160 out_thaw: 161 thaw_processes(); 162 out: 163 shutting_down = SHUTDOWN_INVALID; 164 } 165 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 166 167 struct shutdown_handler { 168 #define SHUTDOWN_CMD_SIZE 11 169 const char command[SHUTDOWN_CMD_SIZE]; 170 bool flag; 171 void (*cb)(void); 172 }; 173 174 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused) 175 { 176 switch (code) { 177 case SYS_DOWN: 178 case SYS_HALT: 179 case SYS_POWER_OFF: 180 shutting_down = SHUTDOWN_POWEROFF; 181 default: 182 break; 183 } 184 return NOTIFY_DONE; 185 } 186 static void do_poweroff(void) 187 { 188 switch (system_state) { 189 case SYSTEM_BOOTING: 190 case SYSTEM_SCHEDULING: 191 orderly_poweroff(true); 192 break; 193 case SYSTEM_RUNNING: 194 orderly_poweroff(false); 195 break; 196 default: 197 /* Don't do it when we are halting/rebooting. */ 198 pr_info("Ignoring Xen toolstack shutdown.\n"); 199 break; 200 } 201 } 202 203 static void do_reboot(void) 204 { 205 shutting_down = SHUTDOWN_POWEROFF; /* ? */ 206 ctrl_alt_del(); 207 } 208 209 static struct shutdown_handler shutdown_handlers[] = { 210 { "poweroff", true, do_poweroff }, 211 { "halt", false, do_poweroff }, 212 { "reboot", true, do_reboot }, 213 #ifdef CONFIG_HIBERNATE_CALLBACKS 214 { "suspend", true, do_suspend }, 215 #endif 216 }; 217 218 static void shutdown_handler(struct xenbus_watch *watch, 219 const char *path, const char *token) 220 { 221 char *str; 222 struct xenbus_transaction xbt; 223 int err; 224 int idx; 225 226 if (shutting_down != SHUTDOWN_INVALID) 227 return; 228 229 again: 230 err = xenbus_transaction_start(&xbt); 231 if (err) 232 return; 233 234 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL); 235 /* Ignore read errors and empty reads. */ 236 if (XENBUS_IS_ERR_READ(str)) { 237 xenbus_transaction_end(xbt, 1); 238 return; 239 } 240 241 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) { 242 if (strcmp(str, shutdown_handlers[idx].command) == 0) 243 break; 244 } 245 246 /* Only acknowledge commands which we are prepared to handle. */ 247 if (idx < ARRAY_SIZE(shutdown_handlers)) 248 xenbus_write(xbt, "control", "shutdown", ""); 249 250 err = xenbus_transaction_end(xbt, 0); 251 if (err == -EAGAIN) { 252 kfree(str); 253 goto again; 254 } 255 256 if (idx < ARRAY_SIZE(shutdown_handlers)) { 257 shutdown_handlers[idx].cb(); 258 } else { 259 pr_info("Ignoring shutdown request: %s\n", str); 260 shutting_down = SHUTDOWN_INVALID; 261 } 262 263 kfree(str); 264 } 265 266 #ifdef CONFIG_MAGIC_SYSRQ 267 static void sysrq_handler(struct xenbus_watch *watch, const char *path, 268 const char *token) 269 { 270 char sysrq_key = '\0'; 271 struct xenbus_transaction xbt; 272 int err; 273 274 again: 275 err = xenbus_transaction_start(&xbt); 276 if (err) 277 return; 278 err = xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key); 279 if (err < 0) { 280 /* 281 * The Xenstore watch fires directly after registering it and 282 * after a suspend/resume cycle. So ENOENT is no error but 283 * might happen in those cases. 284 */ 285 if (err != -ENOENT) 286 pr_err("Error %d reading sysrq code in control/sysrq\n", 287 err); 288 xenbus_transaction_end(xbt, 1); 289 return; 290 } 291 292 if (sysrq_key != '\0') { 293 err = xenbus_printf(xbt, "control", "sysrq", "%c", '\0'); 294 if (err) { 295 pr_err("%s: Error %d writing sysrq in control/sysrq\n", 296 __func__, err); 297 xenbus_transaction_end(xbt, 1); 298 return; 299 } 300 } 301 302 err = xenbus_transaction_end(xbt, 0); 303 if (err == -EAGAIN) 304 goto again; 305 306 if (sysrq_key != '\0') 307 handle_sysrq(sysrq_key); 308 } 309 310 static struct xenbus_watch sysrq_watch = { 311 .node = "control/sysrq", 312 .callback = sysrq_handler 313 }; 314 #endif 315 316 static struct xenbus_watch shutdown_watch = { 317 .node = "control/shutdown", 318 .callback = shutdown_handler 319 }; 320 321 static struct notifier_block xen_reboot_nb = { 322 .notifier_call = poweroff_nb, 323 }; 324 325 static int setup_shutdown_watcher(void) 326 { 327 int err; 328 int idx; 329 #define FEATURE_PATH_SIZE (SHUTDOWN_CMD_SIZE + sizeof("feature-")) 330 char node[FEATURE_PATH_SIZE]; 331 332 err = register_xenbus_watch(&shutdown_watch); 333 if (err) { 334 pr_err("Failed to set shutdown watcher\n"); 335 return err; 336 } 337 338 339 #ifdef CONFIG_MAGIC_SYSRQ 340 err = register_xenbus_watch(&sysrq_watch); 341 if (err) { 342 pr_err("Failed to set sysrq watcher\n"); 343 return err; 344 } 345 #endif 346 347 for (idx = 0; idx < ARRAY_SIZE(shutdown_handlers); idx++) { 348 if (!shutdown_handlers[idx].flag) 349 continue; 350 snprintf(node, FEATURE_PATH_SIZE, "feature-%s", 351 shutdown_handlers[idx].command); 352 err = xenbus_printf(XBT_NIL, "control", node, "%u", 1); 353 if (err) { 354 pr_err("%s: Error %d writing %s\n", __func__, 355 err, node); 356 return err; 357 } 358 } 359 360 return 0; 361 } 362 363 static int shutdown_event(struct notifier_block *notifier, 364 unsigned long event, 365 void *data) 366 { 367 setup_shutdown_watcher(); 368 return NOTIFY_DONE; 369 } 370 371 int xen_setup_shutdown_event(void) 372 { 373 static struct notifier_block xenstore_notifier = { 374 .notifier_call = shutdown_event 375 }; 376 377 if (!xen_domain()) 378 return -ENODEV; 379 register_xenstore_notifier(&xenstore_notifier); 380 register_reboot_notifier(&xen_reboot_nb); 381 382 return 0; 383 } 384 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); 385 386 subsys_initcall(xen_setup_shutdown_event); 387