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 }; 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_mfn(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 failed %d\n", __func__, err); 109 goto out; 110 } 111 112 err = dpm_suspend_start(PMSG_FREEZE); 113 if (err) { 114 pr_err("%s: dpm_suspend_start %d\n", __func__, err); 115 goto out_thaw; 116 } 117 118 printk(KERN_DEBUG "suspending xenstore...\n"); 119 xs_suspend(); 120 121 err = dpm_suspend_end(PMSG_FREEZE); 122 if (err) { 123 pr_err("dpm_suspend_end failed: %d\n", err); 124 si.cancelled = 0; 125 goto out_resume; 126 } 127 128 si.cancelled = 1; 129 130 err = stop_machine(xen_suspend, &si, cpumask_of(0)); 131 132 /* Resume console as early as possible. */ 133 if (!si.cancelled) 134 xen_console_resume(); 135 136 raw_notifier_call_chain(&xen_resume_notifier, 0, NULL); 137 138 dpm_resume_start(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 139 140 if (err) { 141 pr_err("failed to start xen_suspend: %d\n", err); 142 si.cancelled = 1; 143 } 144 145 out_resume: 146 if (!si.cancelled) { 147 xen_arch_resume(); 148 xs_resume(); 149 } else 150 xs_suspend_cancel(); 151 152 dpm_resume_end(si.cancelled ? PMSG_THAW : PMSG_RESTORE); 153 154 out_thaw: 155 thaw_processes(); 156 out: 157 shutting_down = SHUTDOWN_INVALID; 158 } 159 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 160 161 struct shutdown_handler { 162 const char *command; 163 void (*cb)(void); 164 }; 165 166 static int poweroff_nb(struct notifier_block *cb, unsigned long code, void *unused) 167 { 168 switch (code) { 169 case SYS_DOWN: 170 case SYS_HALT: 171 case SYS_POWER_OFF: 172 shutting_down = SHUTDOWN_POWEROFF; 173 default: 174 break; 175 } 176 return NOTIFY_DONE; 177 } 178 static void do_poweroff(void) 179 { 180 switch (system_state) { 181 case SYSTEM_BOOTING: 182 orderly_poweroff(true); 183 break; 184 case SYSTEM_RUNNING: 185 orderly_poweroff(false); 186 break; 187 default: 188 /* Don't do it when we are halting/rebooting. */ 189 pr_info("Ignoring Xen toolstack shutdown.\n"); 190 break; 191 } 192 } 193 194 static void do_reboot(void) 195 { 196 shutting_down = SHUTDOWN_POWEROFF; /* ? */ 197 ctrl_alt_del(); 198 } 199 200 static void shutdown_handler(struct xenbus_watch *watch, 201 const char **vec, unsigned int len) 202 { 203 char *str; 204 struct xenbus_transaction xbt; 205 int err; 206 static struct shutdown_handler handlers[] = { 207 { "poweroff", do_poweroff }, 208 { "halt", do_poweroff }, 209 { "reboot", do_reboot }, 210 #ifdef CONFIG_HIBERNATE_CALLBACKS 211 { "suspend", do_suspend }, 212 #endif 213 {NULL, NULL}, 214 }; 215 static struct shutdown_handler *handler; 216 217 if (shutting_down != SHUTDOWN_INVALID) 218 return; 219 220 again: 221 err = xenbus_transaction_start(&xbt); 222 if (err) 223 return; 224 225 str = (char *)xenbus_read(xbt, "control", "shutdown", NULL); 226 /* Ignore read errors and empty reads. */ 227 if (XENBUS_IS_ERR_READ(str)) { 228 xenbus_transaction_end(xbt, 1); 229 return; 230 } 231 232 for (handler = &handlers[0]; handler->command; handler++) { 233 if (strcmp(str, handler->command) == 0) 234 break; 235 } 236 237 /* Only acknowledge commands which we are prepared to handle. */ 238 if (handler->cb) 239 xenbus_write(xbt, "control", "shutdown", ""); 240 241 err = xenbus_transaction_end(xbt, 0); 242 if (err == -EAGAIN) { 243 kfree(str); 244 goto again; 245 } 246 247 if (handler->cb) { 248 handler->cb(); 249 } else { 250 pr_info("Ignoring shutdown request: %s\n", str); 251 shutting_down = SHUTDOWN_INVALID; 252 } 253 254 kfree(str); 255 } 256 257 #ifdef CONFIG_MAGIC_SYSRQ 258 static void sysrq_handler(struct xenbus_watch *watch, const char **vec, 259 unsigned int len) 260 { 261 char sysrq_key = '\0'; 262 struct xenbus_transaction xbt; 263 int err; 264 265 again: 266 err = xenbus_transaction_start(&xbt); 267 if (err) 268 return; 269 if (!xenbus_scanf(xbt, "control", "sysrq", "%c", &sysrq_key)) { 270 pr_err("Unable to read sysrq code in control/sysrq\n"); 271 xenbus_transaction_end(xbt, 1); 272 return; 273 } 274 275 if (sysrq_key != '\0') 276 xenbus_printf(xbt, "control", "sysrq", "%c", '\0'); 277 278 err = xenbus_transaction_end(xbt, 0); 279 if (err == -EAGAIN) 280 goto again; 281 282 if (sysrq_key != '\0') 283 handle_sysrq(sysrq_key); 284 } 285 286 static struct xenbus_watch sysrq_watch = { 287 .node = "control/sysrq", 288 .callback = sysrq_handler 289 }; 290 #endif 291 292 static struct xenbus_watch shutdown_watch = { 293 .node = "control/shutdown", 294 .callback = shutdown_handler 295 }; 296 297 static struct notifier_block xen_reboot_nb = { 298 .notifier_call = poweroff_nb, 299 }; 300 301 static int setup_shutdown_watcher(void) 302 { 303 int err; 304 305 err = register_xenbus_watch(&shutdown_watch); 306 if (err) { 307 pr_err("Failed to set shutdown watcher\n"); 308 return err; 309 } 310 311 312 #ifdef CONFIG_MAGIC_SYSRQ 313 err = register_xenbus_watch(&sysrq_watch); 314 if (err) { 315 pr_err("Failed to set sysrq watcher\n"); 316 return err; 317 } 318 #endif 319 320 return 0; 321 } 322 323 static int shutdown_event(struct notifier_block *notifier, 324 unsigned long event, 325 void *data) 326 { 327 setup_shutdown_watcher(); 328 return NOTIFY_DONE; 329 } 330 331 int xen_setup_shutdown_event(void) 332 { 333 static struct notifier_block xenstore_notifier = { 334 .notifier_call = shutdown_event 335 }; 336 337 if (!xen_domain()) 338 return -ENODEV; 339 register_xenstore_notifier(&xenstore_notifier); 340 register_reboot_notifier(&xen_reboot_nb); 341 342 return 0; 343 } 344 EXPORT_SYMBOL_GPL(xen_setup_shutdown_event); 345 346 subsys_initcall(xen_setup_shutdown_event); 347