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 /* Dell */ 195 { /* Handle problems with rebooting on Dell DXP061 */ 196 .callback = set_bios_reboot, 197 .ident = "Dell DXP061", 198 .matches = { 199 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 200 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"), 201 }, 202 }, 203 { /* Handle problems with rebooting on Dell E520's */ 204 .callback = set_bios_reboot, 205 .ident = "Dell E520", 206 .matches = { 207 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 208 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"), 209 }, 210 }, 211 { /* Handle problems with rebooting on the Latitude E5410. */ 212 .callback = set_pci_reboot, 213 .ident = "Dell Latitude E5410", 214 .matches = { 215 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 216 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5410"), 217 }, 218 }, 219 { /* Handle problems with rebooting on the Latitude E5420. */ 220 .callback = set_pci_reboot, 221 .ident = "Dell Latitude E5420", 222 .matches = { 223 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 224 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"), 225 }, 226 }, 227 { /* Handle problems with rebooting on the Latitude E6320. */ 228 .callback = set_pci_reboot, 229 .ident = "Dell Latitude E6320", 230 .matches = { 231 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 232 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"), 233 }, 234 }, 235 { /* Handle problems with rebooting on the Latitude E6420. */ 236 .callback = set_pci_reboot, 237 .ident = "Dell Latitude E6420", 238 .matches = { 239 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 240 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"), 241 }, 242 }, 243 { /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */ 244 .callback = set_bios_reboot, 245 .ident = "Dell OptiPlex 330", 246 .matches = { 247 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 248 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"), 249 DMI_MATCH(DMI_BOARD_NAME, "0KP561"), 250 }, 251 }, 252 { /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */ 253 .callback = set_bios_reboot, 254 .ident = "Dell OptiPlex 360", 255 .matches = { 256 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 257 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"), 258 DMI_MATCH(DMI_BOARD_NAME, "0T656F"), 259 }, 260 }, 261 { /* Handle problems with rebooting on Dell Optiplex 745's SFF */ 262 .callback = set_bios_reboot, 263 .ident = "Dell OptiPlex 745", 264 .matches = { 265 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 266 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 267 }, 268 }, 269 { /* Handle problems with rebooting on Dell Optiplex 745's DFF */ 270 .callback = set_bios_reboot, 271 .ident = "Dell OptiPlex 745", 272 .matches = { 273 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 274 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 275 DMI_MATCH(DMI_BOARD_NAME, "0MM599"), 276 }, 277 }, 278 { /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */ 279 .callback = set_bios_reboot, 280 .ident = "Dell OptiPlex 745", 281 .matches = { 282 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 283 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 284 DMI_MATCH(DMI_BOARD_NAME, "0KW626"), 285 }, 286 }, 287 { /* Handle problems with rebooting on Dell OptiPlex 760 with 0G919G */ 288 .callback = set_bios_reboot, 289 .ident = "Dell OptiPlex 760", 290 .matches = { 291 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 292 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 760"), 293 DMI_MATCH(DMI_BOARD_NAME, "0G919G"), 294 }, 295 }, 296 { /* Handle problems with rebooting on the OptiPlex 990. */ 297 .callback = set_pci_reboot, 298 .ident = "Dell OptiPlex 990", 299 .matches = { 300 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 301 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 990"), 302 }, 303 }, 304 { /* Handle problems with rebooting on Dell 300's */ 305 .callback = set_bios_reboot, 306 .ident = "Dell PowerEdge 300", 307 .matches = { 308 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 309 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"), 310 }, 311 }, 312 { /* Handle problems with rebooting on Dell 1300's */ 313 .callback = set_bios_reboot, 314 .ident = "Dell PowerEdge 1300", 315 .matches = { 316 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 317 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"), 318 }, 319 }, 320 { /* Handle problems with rebooting on Dell 2400's */ 321 .callback = set_bios_reboot, 322 .ident = "Dell PowerEdge 2400", 323 .matches = { 324 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 325 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"), 326 }, 327 }, 328 { /* Handle problems with rebooting on the Dell PowerEdge C6100. */ 329 .callback = set_pci_reboot, 330 .ident = "Dell PowerEdge C6100", 331 .matches = { 332 DMI_MATCH(DMI_SYS_VENDOR, "Dell"), 333 DMI_MATCH(DMI_PRODUCT_NAME, "C6100"), 334 }, 335 }, 336 { /* Handle problems with rebooting on the Precision M6600. */ 337 .callback = set_pci_reboot, 338 .ident = "Dell Precision M6600", 339 .matches = { 340 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 341 DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"), 342 }, 343 }, 344 { /* Handle problems with rebooting on Dell T5400's */ 345 .callback = set_bios_reboot, 346 .ident = "Dell Precision T5400", 347 .matches = { 348 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 349 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"), 350 }, 351 }, 352 { /* Handle problems with rebooting on Dell T7400's */ 353 .callback = set_bios_reboot, 354 .ident = "Dell Precision T7400", 355 .matches = { 356 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 357 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T7400"), 358 }, 359 }, 360 { /* Handle problems with rebooting on Dell XPS710 */ 361 .callback = set_bios_reboot, 362 .ident = "Dell XPS710", 363 .matches = { 364 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 365 DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"), 366 }, 367 }, 368 369 /* Hewlett-Packard */ 370 { /* Handle problems with rebooting on HP laptops */ 371 .callback = set_bios_reboot, 372 .ident = "HP Compaq Laptop", 373 .matches = { 374 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 375 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"), 376 }, 377 }, 378 379 /* Sony */ 380 { /* Handle problems with rebooting on Sony VGN-Z540N */ 381 .callback = set_bios_reboot, 382 .ident = "Sony VGN-Z540N", 383 .matches = { 384 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 385 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"), 386 }, 387 }, 388 389 { } 390 }; 391 392 static int __init reboot_init(void) 393 { 394 /* 395 * Only do the DMI check if reboot_type hasn't been overridden 396 * on the command line 397 */ 398 if (reboot_default) 399 dmi_check_system(reboot_dmi_table); 400 return 0; 401 } 402 core_initcall(reboot_init); 403 404 static inline void kb_wait(void) 405 { 406 int i; 407 408 for (i = 0; i < 0x10000; i++) { 409 if ((inb(0x64) & 0x02) == 0) 410 break; 411 udelay(2); 412 } 413 } 414 415 static void vmxoff_nmi(int cpu, struct pt_regs *regs) 416 { 417 cpu_emergency_vmxoff(); 418 } 419 420 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ 421 static void emergency_vmx_disable_all(void) 422 { 423 /* Just make sure we won't change CPUs while doing this */ 424 local_irq_disable(); 425 426 /* 427 * We need to disable VMX on all CPUs before rebooting, otherwise 428 * we risk hanging up the machine, because the CPU ignore INIT 429 * signals when VMX is enabled. 430 * 431 * We can't take any locks and we may be on an inconsistent 432 * state, so we use NMIs as IPIs to tell the other CPUs to disable 433 * VMX and halt. 434 * 435 * For safety, we will avoid running the nmi_shootdown_cpus() 436 * stuff unnecessarily, but we don't have a way to check 437 * if other CPUs have VMX enabled. So we will call it only if the 438 * CPU we are running on has VMX enabled. 439 * 440 * We will miss cases where VMX is not enabled on all CPUs. This 441 * shouldn't do much harm because KVM always enable VMX on all 442 * CPUs anyway. But we can miss it on the small window where KVM 443 * is still enabling VMX. 444 */ 445 if (cpu_has_vmx() && cpu_vmx_enabled()) { 446 /* Disable VMX on this CPU. */ 447 cpu_vmxoff(); 448 449 /* Halt and disable VMX on the other CPUs */ 450 nmi_shootdown_cpus(vmxoff_nmi); 451 452 } 453 } 454 455 456 void __attribute__((weak)) mach_reboot_fixups(void) 457 { 458 } 459 460 /* 461 * To the best of our knowledge Windows compatible x86 hardware expects 462 * the following on reboot: 463 * 464 * 1) If the FADT has the ACPI reboot register flag set, try it 465 * 2) If still alive, write to the keyboard controller 466 * 3) If still alive, write to the ACPI reboot register again 467 * 4) If still alive, write to the keyboard controller again 468 * 5) If still alive, call the EFI runtime service to reboot 469 * 6) If no EFI runtime service, call the BIOS to do a reboot 470 * 471 * We default to following the same pattern. We also have 472 * two other reboot methods: 'triple fault' and 'PCI', which 473 * can be triggered via the reboot= kernel boot option or 474 * via quirks. 475 * 476 * This means that this function can never return, it can misbehave 477 * by not rebooting properly and hanging. 478 */ 479 static void native_machine_emergency_restart(void) 480 { 481 int i; 482 int attempt = 0; 483 int orig_reboot_type = reboot_type; 484 unsigned short mode; 485 486 if (reboot_emergency) 487 emergency_vmx_disable_all(); 488 489 tboot_shutdown(TB_SHUTDOWN_REBOOT); 490 491 /* Tell the BIOS if we want cold or warm reboot */ 492 mode = reboot_mode == REBOOT_WARM ? 0x1234 : 0; 493 *((unsigned short *)__va(0x472)) = mode; 494 495 for (;;) { 496 /* Could also try the reset bit in the Hammer NB */ 497 switch (reboot_type) { 498 case BOOT_ACPI: 499 acpi_reboot(); 500 reboot_type = BOOT_KBD; 501 break; 502 503 case BOOT_KBD: 504 mach_reboot_fixups(); /* For board specific fixups */ 505 506 for (i = 0; i < 10; i++) { 507 kb_wait(); 508 udelay(50); 509 outb(0xfe, 0x64); /* Pulse reset low */ 510 udelay(50); 511 } 512 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 513 attempt = 1; 514 reboot_type = BOOT_ACPI; 515 } else { 516 reboot_type = BOOT_EFI; 517 } 518 break; 519 520 case BOOT_EFI: 521 if (efi_enabled(EFI_RUNTIME_SERVICES)) 522 efi.reset_system(reboot_mode == REBOOT_WARM ? 523 EFI_RESET_WARM : 524 EFI_RESET_COLD, 525 EFI_SUCCESS, 0, NULL); 526 reboot_type = BOOT_BIOS; 527 break; 528 529 case BOOT_BIOS: 530 machine_real_restart(MRR_BIOS); 531 532 /* We're probably dead after this, but... */ 533 reboot_type = BOOT_CF9_SAFE; 534 break; 535 536 case BOOT_CF9_FORCE: 537 port_cf9_safe = true; 538 /* Fall through */ 539 540 case BOOT_CF9_SAFE: 541 if (port_cf9_safe) { 542 u8 reboot_code = reboot_mode == REBOOT_WARM ? 0x06 : 0x0E; 543 u8 cf9 = inb(0xcf9) & ~reboot_code; 544 outb(cf9|2, 0xcf9); /* Request hard reset */ 545 udelay(50); 546 /* Actually do the reset */ 547 outb(cf9|reboot_code, 0xcf9); 548 udelay(50); 549 } 550 reboot_type = BOOT_TRIPLE; 551 break; 552 553 case BOOT_TRIPLE: 554 load_idt(&no_idt); 555 __asm__ __volatile__("int3"); 556 557 /* We're probably dead after this, but... */ 558 reboot_type = BOOT_KBD; 559 break; 560 } 561 } 562 } 563 564 void native_machine_shutdown(void) 565 { 566 /* Stop the cpus and apics */ 567 #ifdef CONFIG_X86_IO_APIC 568 /* 569 * Disabling IO APIC before local APIC is a workaround for 570 * erratum AVR31 in "Intel Atom Processor C2000 Product Family 571 * Specification Update". In this situation, interrupts that target 572 * a Logical Processor whose Local APIC is either in the process of 573 * being hardware disabled or software disabled are neither delivered 574 * nor discarded. When this erratum occurs, the processor may hang. 575 * 576 * Even without the erratum, it still makes sense to quiet IO APIC 577 * before disabling Local APIC. 578 */ 579 disable_IO_APIC(); 580 #endif 581 582 #ifdef CONFIG_SMP 583 /* 584 * Stop all of the others. Also disable the local irq to 585 * not receive the per-cpu timer interrupt which may trigger 586 * scheduler's load balance. 587 */ 588 local_irq_disable(); 589 stop_other_cpus(); 590 #endif 591 592 lapic_shutdown(); 593 594 #ifdef CONFIG_HPET_TIMER 595 hpet_disable(); 596 #endif 597 598 #ifdef CONFIG_X86_64 599 x86_platform.iommu_shutdown(); 600 #endif 601 } 602 603 static void __machine_emergency_restart(int emergency) 604 { 605 reboot_emergency = emergency; 606 machine_ops.emergency_restart(); 607 } 608 609 static void native_machine_restart(char *__unused) 610 { 611 pr_notice("machine restart\n"); 612 613 if (!reboot_force) 614 machine_shutdown(); 615 __machine_emergency_restart(0); 616 } 617 618 static void native_machine_halt(void) 619 { 620 /* Stop other cpus and apics */ 621 machine_shutdown(); 622 623 tboot_shutdown(TB_SHUTDOWN_HALT); 624 625 stop_this_cpu(NULL); 626 } 627 628 static void native_machine_power_off(void) 629 { 630 if (pm_power_off) { 631 if (!reboot_force) 632 machine_shutdown(); 633 pm_power_off(); 634 } 635 /* A fallback in case there is no PM info available */ 636 tboot_shutdown(TB_SHUTDOWN_HALT); 637 } 638 639 struct machine_ops machine_ops = { 640 .power_off = native_machine_power_off, 641 .shutdown = native_machine_shutdown, 642 .emergency_restart = native_machine_emergency_restart, 643 .restart = native_machine_restart, 644 .halt = native_machine_halt, 645 #ifdef CONFIG_KEXEC 646 .crash_shutdown = native_machine_crash_shutdown, 647 #endif 648 }; 649 650 void machine_power_off(void) 651 { 652 machine_ops.power_off(); 653 } 654 655 void machine_shutdown(void) 656 { 657 machine_ops.shutdown(); 658 } 659 660 void machine_emergency_restart(void) 661 { 662 __machine_emergency_restart(1); 663 } 664 665 void machine_restart(char *cmd) 666 { 667 machine_ops.restart(cmd); 668 } 669 670 void machine_halt(void) 671 { 672 machine_ops.halt(); 673 } 674 675 #ifdef CONFIG_KEXEC 676 void machine_crash_shutdown(struct pt_regs *regs) 677 { 678 machine_ops.crash_shutdown(regs); 679 } 680 #endif 681 682 683 #if defined(CONFIG_SMP) 684 685 /* This keeps a track of which one is crashing cpu. */ 686 static int crashing_cpu; 687 static nmi_shootdown_cb shootdown_callback; 688 689 static atomic_t waiting_for_crash_ipi; 690 691 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) 692 { 693 int cpu; 694 695 cpu = raw_smp_processor_id(); 696 697 /* 698 * Don't do anything if this handler is invoked on crashing cpu. 699 * Otherwise, system will completely hang. Crashing cpu can get 700 * an NMI if system was initially booted with nmi_watchdog parameter. 701 */ 702 if (cpu == crashing_cpu) 703 return NMI_HANDLED; 704 local_irq_disable(); 705 706 shootdown_callback(cpu, regs); 707 708 atomic_dec(&waiting_for_crash_ipi); 709 /* Assume hlt works */ 710 halt(); 711 for (;;) 712 cpu_relax(); 713 714 return NMI_HANDLED; 715 } 716 717 static void smp_send_nmi_allbutself(void) 718 { 719 apic->send_IPI_allbutself(NMI_VECTOR); 720 } 721 722 /* 723 * Halt all other CPUs, calling the specified function on each of them 724 * 725 * This function can be used to halt all other CPUs on crash 726 * or emergency reboot time. The function passed as parameter 727 * will be called inside a NMI handler on all CPUs. 728 */ 729 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 730 { 731 unsigned long msecs; 732 local_irq_disable(); 733 734 /* Make a note of crashing cpu. Will be used in NMI callback. */ 735 crashing_cpu = safe_smp_processor_id(); 736 737 shootdown_callback = callback; 738 739 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); 740 /* Would it be better to replace the trap vector here? */ 741 if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, 742 NMI_FLAG_FIRST, "crash")) 743 return; /* Return what? */ 744 /* 745 * Ensure the new callback function is set before sending 746 * out the NMI 747 */ 748 wmb(); 749 750 smp_send_nmi_allbutself(); 751 752 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 753 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 754 mdelay(1); 755 msecs--; 756 } 757 758 /* Leave the nmi callback set */ 759 } 760 #else /* !CONFIG_SMP */ 761 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 762 { 763 /* No other CPUs to shoot down */ 764 } 765 #endif 766