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