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 const char *command; 172 void (*cb)(void); 173 }; 174 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; 182 default: 183 break; 184 } 185 return NOTIFY_DONE; 186 } 187 static void do_poweroff(void) 188 { 189 switch (system_state) { 190 case SYSTEM_BOOTING: 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 void shutdown_handler(struct xenbus_watch *watch, 210 const char **vec, unsigned int len) 211 { 212 char *str; 213 struct xenbus_transaction xbt; 214 int err; 215 static struct shutdown_handler handlers[] = { 216 { "poweroff", do_poweroff }, 217 { "halt", do_poweroff }, 218 { "reboot", do_reboot }, 219 #ifdef CONFIG_HIBERNATE_CALLBACKS 220 { "suspend", do_suspend }, 221 #endif 222 {NULL, NULL}, 223 }; 224 static struct shutdown_handler *handler; 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 (handler = &handlers[0]; handler->command; handler++) { 242 if (strcmp(str, handler->command) == 0) 243 break; 244 } 245 246 /* Only acknowledge commands which we are prepared to handle. */ 247 if (handler->cb) 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 (handler->cb) { 257 handler->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 **vec, 268 unsigned int len) 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 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) { 279 pr_err("Unable to read sysrq code in control/sysrq\n"); 280 xenbus_transaction_end(xbt, 1); 281 return; 282 } 283 284 if (sysrq_key != '\0') 285 xenbus_printf(xbt, "control", "sysrq", "%c", '\0'); 286 287 err = xenbus_transaction_end(xbt, 0); 288 if (err == -EAGAIN) 289 goto again; 290 291 if (sysrq_key != '\0') 292 handle_sysrq(sysrq_key); 293 } 294 295 static struct xenbus_watch sysrq_watch = { 296 .node = "control/sysrq", 297 .callback = sysrq_handler 298 }; 299 #endif 300 301 static struct xenbus_watch shutdown_watch = { 302 .node = "control/shutdown", 303 .callback = shutdown_handler 304 }; 305 306 static struct notifier_block xen_reboot_nb = { 307 .notifier_call = poweroff_nb, 308 }; 309 310 static int setup_shutdown_watcher(void) 311 { 312 int err; 313 314 err = register_xenbus_watch(&shutdown_watch); 315 if (err) { 316 pr_err("Failed to set shutdown watcher\n"); 317 return err; 318 } 319 320 321 #ifdef CONFIG_MAGIC_SYSRQ 322 err = register_xenbus_watch(&sysrq_watch); 323 if (err) { 324 pr_err("Failed to set sysrq watcher\n"); 325 return err; 326 } 327 #endif 328 329 return 0; 330 } 331 332 static int shutdown_event(struct notifier_block *notifier, 333 unsigned long event, 334 void *data) 335 { 336 setup_shutdown_watcher(); 337 return NOTIFY_DONE; 338 } 339 340 int xen_setup_shutdown_event(void) 341 { 342 static struct notifier_block xenstore_notifier = { 343 .notifier_call = shutdown_event 344 }; 345 346 if (!xen_domain()) 347 return -ENODEV; 348 register_xenstore_notifier(&xenstore_notifier); 349 register_reboot_notifier(&xen_reboot_nb); 350 351 return 0; 352 } 353 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); 354 355 subsys_initcall(xen_setup_shutdown_event); 356