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/xen-ops.h> 23 24 #include <asm/xen/hypercall.h> 25 #include <asm/xen/page.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 unsigned long arg; /* extra hypercall argument */ 45 void (*pre)(void); 46 void (*post)(int cancelled); 47 }; 48 49 static RAW_NOTIFIER_HEAD(xen_resume_notifier); 50 51 void xen_resume_notifier_register(struct notifier_block *nb) 52 { 53 raw_notifier_chain_register(&xen_resume_notifier, nb); 54 } 55 EXPORT_SYMBOL_GPL(xen_resume_notifier_register); 56 57 void xen_resume_notifier_unregister(struct notifier_block *nb) 58 { 59 raw_notifier_chain_unregister(&xen_resume_notifier, nb); 60 } 61 EXPORT_SYMBOL_GPL(xen_resume_notifier_unregister); 62 63 #ifdef CONFIG_HIBERNATE_CALLBACKS 64 static void xen_hvm_post_suspend(int cancelled) 65 { 66 xen_arch_hvm_post_suspend(cancelled); 67 gnttab_resume(); 68 } 69 70 static void xen_pre_suspend(void) 71 { 72 xen_mm_pin_all(); 73 gnttab_suspend(); 74 xen_arch_pre_suspend(); 75 } 76 77 static void xen_post_suspend(int cancelled) 78 { 79 xen_arch_post_suspend(cancelled); 80 gnttab_resume(); 81 xen_mm_unpin_all(); 82 } 83 84 static int xen_suspend(void *data) 85 { 86 struct suspend_info *si = data; 87 int err; 88 89 BUG_ON(!irqs_disabled()); 90 91 err = syscore_suspend(); 92 if (err) { 93 pr_err("%s: system core suspend failed: %d\n", __func__, err); 94 return err; 95 } 96 97 if (si->pre) 98 si->pre(); 99 100 /* 101 * This hypercall returns 1 if suspend was cancelled 102 * or the domain was merely checkpointed, and 0 if it 103 * is resuming in a new domain. 104 */ 105 si->cancelled = HYPERVISOR_suspend(si->arg); 106 107 if (si->post) 108 si->post(si->cancelled); 109 110 if (!si->cancelled) { 111 xen_irq_resume(); 112 xen_console_resume(); 113 xen_timer_resume(); 114 } 115 116 syscore_resume(); 117 118 return 0; 119 } 120 121 static void do_suspend(void) 122 { 123 int err; 124 struct suspend_info si; 125 126 shutting_down = SHUTDOWN_SUSPEND; 127 128 #ifdef CONFIG_PREEMPT 129 /* If the kernel is preemptible, we need to freeze all the processes 130 to prevent them from being in the middle of a pagetable update 131 during suspend. */ 132 err = freeze_processes(); 133 if (err) { 134 pr_err("%s: freeze failed %d\n", __func__, err); 135 goto out; 136 } 137 #endif 138 139 err = dpm_suspend_start(PMSG_FREEZE); 140 if (err) { 141 pr_err("%s: dpm_suspend_start %d\n", __func__, err); 142 goto out_thaw; 143 } 144 145 printk(KERN_DEBUG "suspending xenstore...\n"); 146 xs_suspend(); 147 148 err = dpm_suspend_end(PMSG_FREEZE); 149 if (err) { 150 pr_err("dpm_suspend_end failed: %d\n", err); 151 si.cancelled = 0; 152 goto out_resume; 153 } 154 155 si.cancelled = 1; 156 157 if (xen_hvm_domain()) { 158 si.arg = 0UL; 159 si.pre = NULL; 160 si.post = &xen_hvm_post_suspend; 161 } else { 162 si.arg = virt_to_mfn(xen_start_info); 163 si.pre = &xen_pre_suspend; 164 si.post = &xen_post_suspend; 165 } 166 167 err = stop_machine(xen_suspend, &si, cpumask_of(0)); 168 169 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL); 170 171 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 172 173 if (err) { 174 pr_err("failed to start xen_suspend: %d\n", err); 175 si.cancelled = 1; 176 } 177 178 out_resume: 179 if (!si.cancelled) { 180 xen_arch_resume(); 181 xs_resume(); 182 } else 183 xs_suspend_cancel(); 184 185 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 186 187 out_thaw: 188 #ifdef CONFIG_PREEMPT 189 thaw_processes(); 190 out: 191 #endif 192 shutting_down = SHUTDOWN_INVALID; 193 } 194 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 195 196 struct shutdown_handler { 197 const char *command; 198 void (*cb)(void); 199 }; 200 201 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused) 202 { 203 switch (code) { 204 case SYS_DOWN: 205 case SYS_HALT: 206 case SYS_POWER_OFF: 207 shutting_down = SHUTDOWN_POWEROFF; 208 default: 209 break; 210 } 211 return NOTIFY_DONE; 212 } 213 static void do_poweroff(void) 214 { 215 switch (system_state) { 216 case SYSTEM_BOOTING: 217 orderly_poweroff(true); 218 break; 219 case SYSTEM_RUNNING: 220 orderly_poweroff(false); 221 break; 222 default: 223 /* Don't do it when we are halting/rebooting. */ 224 pr_info("Ignoring Xen toolstack shutdown.\n"); 225 break; 226 } 227 } 228 229 static void do_reboot(void) 230 { 231 shutting_down = SHUTDOWN_POWEROFF; /* ? */ 232 ctrl_alt_del(); 233 } 234 235 static void shutdown_handler(struct xenbus_watch *watch, 236 const char **vec, unsigned int len) 237 { 238 char *str; 239 struct xenbus_transaction xbt; 240 int err; 241 static struct shutdown_handler handlers[] = { 242 { "poweroff", do_poweroff }, 243 { "halt", do_poweroff }, 244 { "reboot", do_reboot }, 245 #ifdef CONFIG_HIBERNATE_CALLBACKS 246 { "suspend", do_suspend }, 247 #endif 248 {NULL, NULL}, 249 }; 250 static struct shutdown_handler *handler; 251 252 if (shutting_down != SHUTDOWN_INVALID) 253 return; 254 255 again: 256 err = xenbus_transaction_start(&xbt); 257 if (err) 258 return; 259 260 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL); 261 /* Ignore read errors and empty reads. */ 262 if (XENBUS_IS_ERR_READ(str)) { 263 xenbus_transaction_end(xbt, 1); 264 return; 265 } 266 267 for (handler = &handlers[0]; handler->command; handler++) { 268 if (strcmp(str, handler->command) == 0) 269 break; 270 } 271 272 /* Only acknowledge commands which we are prepared to handle. */ 273 if (handler->cb) 274 xenbus_write(xbt, "control", "shutdown", ""); 275 276 err = xenbus_transaction_end(xbt, 0); 277 if (err == -EAGAIN) { 278 kfree(str); 279 goto again; 280 } 281 282 if (handler->cb) { 283 handler->cb(); 284 } else { 285 pr_info("Ignoring shutdown request: %s\n", str); 286 shutting_down = SHUTDOWN_INVALID; 287 } 288 289 kfree(str); 290 } 291 292 #ifdef CONFIG_MAGIC_SYSRQ 293 static void sysrq_handler(struct xenbus_watch *watch, const char **vec, 294 unsigned int len) 295 { 296 char sysrq_key = '\0'; 297 struct xenbus_transaction xbt; 298 int err; 299 300 again: 301 err = xenbus_transaction_start(&xbt); 302 if (err) 303 return; 304 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) { 305 pr_err("Unable to read sysrq code in control/sysrq\n"); 306 xenbus_transaction_end(xbt, 1); 307 return; 308 } 309 310 if (sysrq_key != '\0') 311 xenbus_printf(xbt, "control", "sysrq", "%c", '\0'); 312 313 err = xenbus_transaction_end(xbt, 0); 314 if (err == -EAGAIN) 315 goto again; 316 317 if (sysrq_key != '\0') 318 handle_sysrq(sysrq_key); 319 } 320 321 static struct xenbus_watch sysrq_watch = { 322 .node = "control/sysrq", 323 .callback = sysrq_handler 324 }; 325 #endif 326 327 static struct xenbus_watch shutdown_watch = { 328 .node = "control/shutdown", 329 .callback = shutdown_handler 330 }; 331 332 static struct notifier_block xen_reboot_nb = { 333 .notifier_call = poweroff_nb, 334 }; 335 336 static int setup_shutdown_watcher(void) 337 { 338 int err; 339 340 err = register_xenbus_watch(&shutdown_watch); 341 if (err) { 342 pr_err("Failed to set shutdown watcher\n"); 343 return err; 344 } 345 346 347 #ifdef CONFIG_MAGIC_SYSRQ 348 err = register_xenbus_watch(&sysrq_watch); 349 if (err) { 350 pr_err("Failed to set sysrq watcher\n"); 351 return err; 352 } 353 #endif 354 355 return 0; 356 } 357 358 static int shutdown_event(struct notifier_block *notifier, 359 unsigned long event, 360 void *data) 361 { 362 setup_shutdown_watcher(); 363 return NOTIFY_DONE; 364 } 365 366 int xen_setup_shutdown_event(void) 367 { 368 static struct notifier_block xenstore_notifier = { 369 .notifier_call = shutdown_event 370 }; 371 372 if (!xen_domain()) 373 return -ENODEV; 374 register_xenstore_notifier(&xenstore_notifier); 375 register_reboot_notifier(&xen_reboot_nb); 376 377 return 0; 378 } 379 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); 380 381 subsys_initcall(xen_setup_shutdown_event); 382