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