1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 2 3 #include <linux/module.h> 4 #include <linux/reboot.h> 5 #include <linux/init.h> 6 #include <linux/pm.h> 7 #include <linux/efi.h> 8 #include <linux/dmi.h> 9 #include <linux/sched.h> 10 #include <linux/tboot.h> 11 #include <linux/delay.h> 12 #include <acpi/reboot.h> 13 #include <asm/io.h> 14 #include <asm/apic.h> 15 #include <asm/desc.h> 16 #include <asm/hpet.h> 17 #include <asm/pgtable.h> 18 #include <asm/proto.h> 19 #include <asm/reboot_fixups.h> 20 #include <asm/reboot.h> 21 #include <asm/pci_x86.h> 22 #include <asm/virtext.h> 23 #include <asm/cpu.h> 24 #include <asm/nmi.h> 25 #include <asm/smp.h> 26 27 #include <linux/ctype.h> 28 #include <linux/mc146818rtc.h> 29 #include <asm/realmode.h> 30 #include <asm/x86_init.h> 31 32 /* 33 * Power off function, if any 34 */ 35 void (*pm_power_off)(void); 36 EXPORT_SYMBOL(pm_power_off); 37 38 static const struct desc_ptr no_idt = {}; 39 40 /* 41 * This is set if we need to go through the 'emergency' path. 42 * When machine_emergency_restart() is called, we may be on 43 * an inconsistent state and won't be able to do a clean cleanup 44 */ 45 static int reboot_emergency; 46 47 /* This is set by the PCI code if either type 1 or type 2 PCI is detected */ 48 bool port_cf9_safe = false; 49 50 /* 51 * Reboot options and system auto-detection code provided by 52 * Dell Inc. so their systems "just work". :-) 53 */ 54 55 /* 56 * Some machines require the "reboot=b" or "reboot=k" commandline options, 57 * this quirk makes that automatic. 58 */ 59 static int __init set_bios_reboot(const struct dmi_system_id *d) 60 { 61 if (reboot_type != BOOT_BIOS) { 62 reboot_type = BOOT_BIOS; 63 pr_info("%s series board detected. Selecting %s-method for reboots.\n", 64 d->ident, "BIOS"); 65 } 66 return 0; 67 } 68 69 void __noreturn machine_real_restart(unsigned int type) 70 { 71 local_irq_disable(); 72 73 /* 74 * Write zero to CMOS register number 0x0f, which the BIOS POST 75 * routine will recognize as telling it to do a proper reboot. (Well 76 * that's what this book in front of me says -- it may only apply to 77 * the Phoenix BIOS though, it's not clear). At the same time, 78 * disable NMIs by setting the top bit in the CMOS address register, 79 * as we're about to do peculiar things to the CPU. I'm not sure if 80 * `outb_p' is needed instead of just `outb'. Use it to be on the 81 * safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.) 82 */ 83 spin_lock(&rtc_lock); 84 CMOS_WRITE(0x00, 0x8f); 85 spin_unlock(&rtc_lock); 86 87 /* 88 * Switch back to the initial page table. 89 */ 90 #ifdef CONFIG_X86_32 91 load_cr3(initial_page_table); 92 #else 93 write_cr3(real_mode_header->trampoline_pgd); 94 #endif 95 96 /* Jump to the identity-mapped low memory code */ 97 #ifdef CONFIG_X86_32 98 asm volatile("jmpl *%0" : : 99 "rm" (real_mode_header->machine_real_restart_asm), 100 "a" (type)); 101 #else 102 asm volatile("ljmpl *%0" : : 103 "m" (real_mode_header->machine_real_restart_asm), 104 "D" (type)); 105 #endif 106 unreachable(); 107 } 108 #ifdef CONFIG_APM_MODULE 109 EXPORT_SYMBOL(machine_real_restart); 110 #endif 111 112 /* 113 * Some Apple MacBook and MacBookPro's needs reboot=p to be able to reboot 114 */ 115 static int __init set_pci_reboot(const struct dmi_system_id *d) 116 { 117 if (reboot_type != BOOT_CF9_FORCE) { 118 reboot_type = BOOT_CF9_FORCE; 119 pr_info("%s series board detected. Selecting %s-method for reboots.\n", 120 d->ident, "PCI"); 121 } 122 return 0; 123 } 124 125 static int __init set_kbd_reboot(const struct dmi_system_id *d) 126 { 127 if (reboot_type != BOOT_KBD) { 128 reboot_type = BOOT_KBD; 129 pr_info("%s series board detected. Selecting %s-method for reboot.\n", 130 d->ident, "KBD"); 131 } 132 return 0; 133 } 134 135 /* 136 * This is a single dmi_table handling all reboot quirks. 137 */ 138 static struct dmi_system_id __initdata reboot_dmi_table[] = { 139 140 /* Acer */ 141 { /* Handle reboot issue on Acer Aspire one */ 142 .callback = set_kbd_reboot, 143 .ident = "Acer Aspire One A110", 144 .matches = { 145 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 146 DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"), 147 }, 148 }, 149 150 /* Apple */ 151 { /* Handle problems with rebooting on Apple MacBook5 */ 152 .callback = set_pci_reboot, 153 .ident = "Apple MacBook5", 154 .matches = { 155 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 156 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5"), 157 }, 158 }, 159 { /* Handle problems with rebooting on Apple MacBookPro5 */ 160 .callback = set_pci_reboot, 161 .ident = "Apple MacBookPro5", 162 .matches = { 163 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 164 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5"), 165 }, 166 }, 167 { /* Handle problems with rebooting on Apple Macmini3,1 */ 168 .callback = set_pci_reboot, 169 .ident = "Apple Macmini3,1", 170 .matches = { 171 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 172 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini3,1"), 173 }, 174 }, 175 { /* Handle problems with rebooting on the iMac9,1. */ 176 .callback = set_pci_reboot, 177 .ident = "Apple iMac9,1", 178 .matches = { 179 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 180 DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1"), 181 }, 182 }, 183 184 /* ASUS */ 185 { /* Handle problems with rebooting on ASUS P4S800 */ 186 .callback = set_bios_reboot, 187 .ident = "ASUS P4S800", 188 .matches = { 189 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 190 DMI_MATCH(DMI_BOARD_NAME, "P4S800"), 191 }, 192 }, 193 194 /* Certec */ 195 { /* Handle problems with rebooting on Certec BPC600 */ 196 .callback = set_pci_reboot, 197 .ident = "Certec BPC600", 198 .matches = { 199 DMI_MATCH(DMI_SYS_VENDOR, "Certec"), 200 DMI_MATCH(DMI_PRODUCT_NAME, "BPC600"), 201 }, 202 }, 203 204 /* Dell */ 205 { /* Handle problems with rebooting on Dell DXP061 */ 206 .callback = set_bios_reboot, 207 .ident = "Dell DXP061", 208 .matches = { 209 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 210 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"), 211 }, 212 }, 213 { /* Handle problems with rebooting on Dell E520's */ 214 .callback = set_bios_reboot, 215 .ident = "Dell E520", 216 .matches = { 217 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 218 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"), 219 }, 220 }, 221 { /* Handle problems with rebooting on the Latitude E5410. */ 222 .callback = set_pci_reboot, 223 .ident = "Dell Latitude E5410", 224 .matches = { 225 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 226 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5410"), 227 }, 228 }, 229 { /* Handle problems with rebooting on the Latitude E5420. */ 230 .callback = set_pci_reboot, 231 .ident = "Dell Latitude E5420", 232 .matches = { 233 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 234 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"), 235 }, 236 }, 237 { /* Handle problems with rebooting on the Latitude E6320. */ 238 .callback = set_pci_reboot, 239 .ident = "Dell Latitude E6320", 240 .matches = { 241 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 242 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"), 243 }, 244 }, 245 { /* Handle problems with rebooting on the Latitude E6420. */ 246 .callback = set_pci_reboot, 247 .ident = "Dell Latitude E6420", 248 .matches = { 249 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 250 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"), 251 }, 252 }, 253 { /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */ 254 .callback = set_bios_reboot, 255 .ident = "Dell OptiPlex 330", 256 .matches = { 257 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 258 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"), 259 DMI_MATCH(DMI_BOARD_NAME, "0KP561"), 260 }, 261 }, 262 { /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */ 263 .callback = set_bios_reboot, 264 .ident = "Dell OptiPlex 360", 265 .matches = { 266 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 267 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"), 268 DMI_MATCH(DMI_BOARD_NAME, "0T656F"), 269 }, 270 }, 271 { /* Handle problems with rebooting on Dell Optiplex 745's SFF */ 272 .callback = set_bios_reboot, 273 .ident = "Dell OptiPlex 745", 274 .matches = { 275 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 276 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 277 }, 278 }, 279 { /* Handle problems with rebooting on Dell Optiplex 745's DFF */ 280 .callback = set_bios_reboot, 281 .ident = "Dell OptiPlex 745", 282 .matches = { 283 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 284 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 285 DMI_MATCH(DMI_BOARD_NAME, "0MM599"), 286 }, 287 }, 288 { /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */ 289 .callback = set_bios_reboot, 290 .ident = "Dell OptiPlex 745", 291 .matches = { 292 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 293 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 294 DMI_MATCH(DMI_BOARD_NAME, "0KW626"), 295 }, 296 }, 297 { /* Handle problems with rebooting on Dell OptiPlex 760 with 0G919G */ 298 .callback = set_bios_reboot, 299 .ident = "Dell OptiPlex 760", 300 .matches = { 301 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 302 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 760"), 303 DMI_MATCH(DMI_BOARD_NAME, "0G919G"), 304 }, 305 }, 306 { /* Handle problems with rebooting on the OptiPlex 990. */ 307 .callback = set_pci_reboot, 308 .ident = "Dell OptiPlex 990", 309 .matches = { 310 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 311 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 990"), 312 }, 313 }, 314 { /* Handle problems with rebooting on Dell 300's */ 315 .callback = set_bios_reboot, 316 .ident = "Dell PowerEdge 300", 317 .matches = { 318 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 319 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"), 320 }, 321 }, 322 { /* Handle problems with rebooting on Dell 1300's */ 323 .callback = set_bios_reboot, 324 .ident = "Dell PowerEdge 1300", 325 .matches = { 326 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 327 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"), 328 }, 329 }, 330 { /* Handle problems with rebooting on Dell 2400's */ 331 .callback = set_bios_reboot, 332 .ident = "Dell PowerEdge 2400", 333 .matches = { 334 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 335 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"), 336 }, 337 }, 338 { /* Handle problems with rebooting on the Dell PowerEdge C6100. */ 339 .callback = set_pci_reboot, 340 .ident = "Dell PowerEdge C6100", 341 .matches = { 342 DMI_MATCH(DMI_SYS_VENDOR, "Dell"), 343 DMI_MATCH(DMI_PRODUCT_NAME, "C6100"), 344 }, 345 }, 346 { /* Handle problems with rebooting on the Precision M6600. */ 347 .callback = set_pci_reboot, 348 .ident = "Dell Precision M6600", 349 .matches = { 350 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 351 DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"), 352 }, 353 }, 354 { /* Handle problems with rebooting on Dell T5400's */ 355 .callback = set_bios_reboot, 356 .ident = "Dell Precision T5400", 357 .matches = { 358 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 359 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"), 360 }, 361 }, 362 { /* Handle problems with rebooting on Dell T7400's */ 363 .callback = set_bios_reboot, 364 .ident = "Dell Precision T7400", 365 .matches = { 366 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 367 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T7400"), 368 }, 369 }, 370 { /* Handle problems with rebooting on Dell XPS710 */ 371 .callback = set_bios_reboot, 372 .ident = "Dell XPS710", 373 .matches = { 374 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 375 DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"), 376 }, 377 }, 378 379 /* Hewlett-Packard */ 380 { /* Handle problems with rebooting on HP laptops */ 381 .callback = set_bios_reboot, 382 .ident = "HP Compaq Laptop", 383 .matches = { 384 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 385 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"), 386 }, 387 }, 388 389 /* Sony */ 390 { /* Handle problems with rebooting on Sony VGN-Z540N */ 391 .callback = set_bios_reboot, 392 .ident = "Sony VGN-Z540N", 393 .matches = { 394 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 395 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"), 396 }, 397 }, 398 399 { } 400 }; 401 402 static int __init reboot_init(void) 403 { 404 /* 405 * Only do the DMI check if reboot_type hasn't been overridden 406 * on the command line 407 */ 408 if (reboot_default) 409 dmi_check_system(reboot_dmi_table); 410 return 0; 411 } 412 core_initcall(reboot_init); 413 414 static inline void kb_wait(void) 415 { 416 int i; 417 418 for (i = 0; i < 0x10000; i++) { 419 if ((inb(0x64) & 0x02) == 0) 420 break; 421 udelay(2); 422 } 423 } 424 425 static void vmxoff_nmi(int cpu, struct pt_regs *regs) 426 { 427 cpu_emergency_vmxoff(); 428 } 429 430 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ 431 static void emergency_vmx_disable_all(void) 432 { 433 /* Just make sure we won't change CPUs while doing this */ 434 local_irq_disable(); 435 436 /* 437 * We need to disable VMX on all CPUs before rebooting, otherwise 438 * we risk hanging up the machine, because the CPU ignore INIT 439 * signals when VMX is enabled. 440 * 441 * We can't take any locks and we may be on an inconsistent 442 * state, so we use NMIs as IPIs to tell the other CPUs to disable 443 * VMX and halt. 444 * 445 * For safety, we will avoid running the nmi_shootdown_cpus() 446 * stuff unnecessarily, but we don't have a way to check 447 * if other CPUs have VMX enabled. So we will call it only if the 448 * CPU we are running on has VMX enabled. 449 * 450 * We will miss cases where VMX is not enabled on all CPUs. This 451 * shouldn't do much harm because KVM always enable VMX on all 452 * CPUs anyway. But we can miss it on the small window where KVM 453 * is still enabling VMX. 454 */ 455 if (cpu_has_vmx() && cpu_vmx_enabled()) { 456 /* Disable VMX on this CPU. */ 457 cpu_vmxoff(); 458 459 /* Halt and disable VMX on the other CPUs */ 460 nmi_shootdown_cpus(vmxoff_nmi); 461 462 } 463 } 464 465 466 void __attribute__((weak)) mach_reboot_fixups(void) 467 { 468 } 469 470 /* 471 * To the best of our knowledge Windows compatible x86 hardware expects 472 * the following on reboot: 473 * 474 * 1) If the FADT has the ACPI reboot register flag set, try it 475 * 2) If still alive, write to the keyboard controller 476 * 3) If still alive, write to the ACPI reboot register again 477 * 4) If still alive, write to the keyboard controller again 478 * 5) If still alive, call the EFI runtime service to reboot 479 * 6) If no EFI runtime service, call the BIOS to do a reboot 480 * 481 * We default to following the same pattern. We also have 482 * two other reboot methods: 'triple fault' and 'PCI', which 483 * can be triggered via the reboot= kernel boot option or 484 * via quirks. 485 * 486 * This means that this function can never return, it can misbehave 487 * by not rebooting properly and hanging. 488 */ 489 static void native_machine_emergency_restart(void) 490 { 491 int i; 492 int attempt = 0; 493 int orig_reboot_type = reboot_type; 494 unsigned short mode; 495 496 if (reboot_emergency) 497 emergency_vmx_disable_all(); 498 499 tboot_shutdown(TB_SHUTDOWN_REBOOT); 500 501 /* Tell the BIOS if we want cold or warm reboot */ 502 mode = reboot_mode == REBOOT_WARM ? 0x1234 : 0; 503 *((unsigned short *)__va(0x472)) = mode; 504 505 for (;;) { 506 /* Could also try the reset bit in the Hammer NB */ 507 switch (reboot_type) { 508 case BOOT_ACPI: 509 acpi_reboot(); 510 reboot_type = BOOT_KBD; 511 break; 512 513 case BOOT_KBD: 514 mach_reboot_fixups(); /* For board specific fixups */ 515 516 for (i = 0; i < 10; i++) { 517 kb_wait(); 518 udelay(50); 519 outb(0xfe, 0x64); /* Pulse reset low */ 520 udelay(50); 521 } 522 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 523 attempt = 1; 524 reboot_type = BOOT_ACPI; 525 } else { 526 reboot_type = BOOT_EFI; 527 } 528 break; 529 530 case BOOT_EFI: 531 if (efi_enabled(EFI_RUNTIME_SERVICES)) 532 efi.reset_system(reboot_mode == REBOOT_WARM ? 533 EFI_RESET_WARM : 534 EFI_RESET_COLD, 535 EFI_SUCCESS, 0, NULL); 536 reboot_type = BOOT_BIOS; 537 break; 538 539 case BOOT_BIOS: 540 machine_real_restart(MRR_BIOS); 541 542 /* We're probably dead after this, but... */ 543 reboot_type = BOOT_CF9_SAFE; 544 break; 545 546 case BOOT_CF9_FORCE: 547 port_cf9_safe = true; 548 /* Fall through */ 549 550 case BOOT_CF9_SAFE: 551 if (port_cf9_safe) { 552 u8 reboot_code = reboot_mode == REBOOT_WARM ? 0x06 : 0x0E; 553 u8 cf9 = inb(0xcf9) & ~reboot_code; 554 outb(cf9|2, 0xcf9); /* Request hard reset */ 555 udelay(50); 556 /* Actually do the reset */ 557 outb(cf9|reboot_code, 0xcf9); 558 udelay(50); 559 } 560 reboot_type = BOOT_TRIPLE; 561 break; 562 563 case BOOT_TRIPLE: 564 load_idt(&no_idt); 565 __asm__ __volatile__("int3"); 566 567 /* We're probably dead after this, but... */ 568 reboot_type = BOOT_KBD; 569 break; 570 } 571 } 572 } 573 574 void native_machine_shutdown(void) 575 { 576 /* Stop the cpus and apics */ 577 #ifdef CONFIG_X86_IO_APIC 578 /* 579 * Disabling IO APIC before local APIC is a workaround for 580 * erratum AVR31 in "Intel Atom Processor C2000 Product Family 581 * Specification Update". In this situation, interrupts that target 582 * a Logical Processor whose Local APIC is either in the process of 583 * being hardware disabled or software disabled are neither delivered 584 * nor discarded. When this erratum occurs, the processor may hang. 585 * 586 * Even without the erratum, it still makes sense to quiet IO APIC 587 * before disabling Local APIC. 588 */ 589 disable_IO_APIC(); 590 #endif 591 592 #ifdef CONFIG_SMP 593 /* 594 * Stop all of the others. Also disable the local irq to 595 * not receive the per-cpu timer interrupt which may trigger 596 * scheduler's load balance. 597 */ 598 local_irq_disable(); 599 stop_other_cpus(); 600 #endif 601 602 lapic_shutdown(); 603 604 #ifdef CONFIG_HPET_TIMER 605 hpet_disable(); 606 #endif 607 608 #ifdef CONFIG_X86_64 609 x86_platform.iommu_shutdown(); 610 #endif 611 } 612 613 static void __machine_emergency_restart(int emergency) 614 { 615 reboot_emergency = emergency; 616 machine_ops.emergency_restart(); 617 } 618 619 static void native_machine_restart(char *__unused) 620 { 621 pr_notice("machine restart\n"); 622 623 if (!reboot_force) 624 machine_shutdown(); 625 __machine_emergency_restart(0); 626 } 627 628 static void native_machine_halt(void) 629 { 630 /* Stop other cpus and apics */ 631 machine_shutdown(); 632 633 tboot_shutdown(TB_SHUTDOWN_HALT); 634 635 stop_this_cpu(NULL); 636 } 637 638 static void native_machine_power_off(void) 639 { 640 if (pm_power_off) { 641 if (!reboot_force) 642 machine_shutdown(); 643 pm_power_off(); 644 } 645 /* A fallback in case there is no PM info available */ 646 tboot_shutdown(TB_SHUTDOWN_HALT); 647 } 648 649 struct machine_ops machine_ops = { 650 .power_off = native_machine_power_off, 651 .shutdown = native_machine_shutdown, 652 .emergency_restart = native_machine_emergency_restart, 653 .restart = native_machine_restart, 654 .halt = native_machine_halt, 655 #ifdef CONFIG_KEXEC 656 .crash_shutdown = native_machine_crash_shutdown, 657 #endif 658 }; 659 660 void machine_power_off(void) 661 { 662 machine_ops.power_off(); 663 } 664 665 void machine_shutdown(void) 666 { 667 machine_ops.shutdown(); 668 } 669 670 void machine_emergency_restart(void) 671 { 672 __machine_emergency_restart(1); 673 } 674 675 void machine_restart(char *cmd) 676 { 677 machine_ops.restart(cmd); 678 } 679 680 void machine_halt(void) 681 { 682 machine_ops.halt(); 683 } 684 685 #ifdef CONFIG_KEXEC 686 void machine_crash_shutdown(struct pt_regs *regs) 687 { 688 machine_ops.crash_shutdown(regs); 689 } 690 #endif 691 692 693 #if defined(CONFIG_SMP) 694 695 /* This keeps a track of which one is crashing cpu. */ 696 static int crashing_cpu; 697 static nmi_shootdown_cb shootdown_callback; 698 699 static atomic_t waiting_for_crash_ipi; 700 701 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) 702 { 703 int cpu; 704 705 cpu = raw_smp_processor_id(); 706 707 /* 708 * Don't do anything if this handler is invoked on crashing cpu. 709 * Otherwise, system will completely hang. Crashing cpu can get 710 * an NMI if system was initially booted with nmi_watchdog parameter. 711 */ 712 if (cpu == crashing_cpu) 713 return NMI_HANDLED; 714 local_irq_disable(); 715 716 shootdown_callback(cpu, regs); 717 718 atomic_dec(&waiting_for_crash_ipi); 719 /* Assume hlt works */ 720 halt(); 721 for (;;) 722 cpu_relax(); 723 724 return NMI_HANDLED; 725 } 726 727 static void smp_send_nmi_allbutself(void) 728 { 729 apic->send_IPI_allbutself(NMI_VECTOR); 730 } 731 732 /* 733 * Halt all other CPUs, calling the specified function on each of them 734 * 735 * This function can be used to halt all other CPUs on crash 736 * or emergency reboot time. The function passed as parameter 737 * will be called inside a NMI handler on all CPUs. 738 */ 739 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 740 { 741 unsigned long msecs; 742 local_irq_disable(); 743 744 /* Make a note of crashing cpu. Will be used in NMI callback. */ 745 crashing_cpu = safe_smp_processor_id(); 746 747 shootdown_callback = callback; 748 749 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); 750 /* Would it be better to replace the trap vector here? */ 751 if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, 752 NMI_FLAG_FIRST, "crash")) 753 return; /* Return what? */ 754 /* 755 * Ensure the new callback function is set before sending 756 * out the NMI 757 */ 758 wmb(); 759 760 smp_send_nmi_allbutself(); 761 762 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 763 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 764 mdelay(1); 765 msecs--; 766 } 767 768 /* Leave the nmi callback set */ 769 } 770 #else /* !CONFIG_SMP */ 771 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 772 { 773 /* No other CPUs to shoot down */ 774 } 775 #endif 776