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