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 */ 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=b" or "reboot=k" commandline options, 59 * this quirk makes that automatic. 60 */ 61 static 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 71 void __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 111 EXPORT_SYMBOL(machine_real_restart); 112 #endif 113 114 /* 115 * Some Apple MacBook and MacBookPro's needs reboot=p to be able to reboot 116 */ 117 static 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 127 static 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 */ 140 static 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 422 static 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 } 445 core_initcall(reboot_init); 446 447 static 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 458 static 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 */ 464 static 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 499 void __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 */ 522 static 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 /* 539 * If an EFI capsule has been registered with the firmware then 540 * override the reboot= parameter. 541 */ 542 if (efi_capsule_pending(NULL)) { 543 pr_info("EFI capsule is pending, forcing EFI reboot.\n"); 544 reboot_type = BOOT_EFI; 545 } 546 547 for (;;) { 548 /* Could also try the reset bit in the Hammer NB */ 549 switch (reboot_type) { 550 case BOOT_ACPI: 551 acpi_reboot(); 552 reboot_type = BOOT_KBD; 553 break; 554 555 case BOOT_KBD: 556 mach_reboot_fixups(); /* For board specific fixups */ 557 558 for (i = 0; i < 10; i++) { 559 kb_wait(); 560 udelay(50); 561 outb(0xfe, 0x64); /* Pulse reset low */ 562 udelay(50); 563 } 564 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 565 attempt = 1; 566 reboot_type = BOOT_ACPI; 567 } else { 568 reboot_type = BOOT_EFI; 569 } 570 break; 571 572 case BOOT_EFI: 573 efi_reboot(reboot_mode, NULL); 574 reboot_type = BOOT_BIOS; 575 break; 576 577 case BOOT_BIOS: 578 machine_real_restart(MRR_BIOS); 579 580 /* We're probably dead after this, but... */ 581 reboot_type = BOOT_CF9_SAFE; 582 break; 583 584 case BOOT_CF9_FORCE: 585 port_cf9_safe = true; 586 /* Fall through */ 587 588 case BOOT_CF9_SAFE: 589 if (port_cf9_safe) { 590 u8 reboot_code = reboot_mode == REBOOT_WARM ? 0x06 : 0x0E; 591 u8 cf9 = inb(0xcf9) & ~reboot_code; 592 outb(cf9|2, 0xcf9); /* Request hard reset */ 593 udelay(50); 594 /* Actually do the reset */ 595 outb(cf9|reboot_code, 0xcf9); 596 udelay(50); 597 } 598 reboot_type = BOOT_TRIPLE; 599 break; 600 601 case BOOT_TRIPLE: 602 load_idt(&no_idt); 603 __asm__ __volatile__("int3"); 604 605 /* We're probably dead after this, but... */ 606 reboot_type = BOOT_KBD; 607 break; 608 } 609 } 610 } 611 612 void native_machine_shutdown(void) 613 { 614 /* Stop the cpus and apics */ 615 #ifdef CONFIG_X86_IO_APIC 616 /* 617 * Disabling IO APIC before local APIC is a workaround for 618 * erratum AVR31 in "Intel Atom Processor C2000 Product Family 619 * Specification Update". In this situation, interrupts that target 620 * a Logical Processor whose Local APIC is either in the process of 621 * being hardware disabled or software disabled are neither delivered 622 * nor discarded. When this erratum occurs, the processor may hang. 623 * 624 * Even without the erratum, it still makes sense to quiet IO APIC 625 * before disabling Local APIC. 626 */ 627 disable_IO_APIC(); 628 #endif 629 630 #ifdef CONFIG_SMP 631 /* 632 * Stop all of the others. Also disable the local irq to 633 * not receive the per-cpu timer interrupt which may trigger 634 * scheduler's load balance. 635 */ 636 local_irq_disable(); 637 stop_other_cpus(); 638 #endif 639 640 lapic_shutdown(); 641 642 #ifdef CONFIG_HPET_TIMER 643 hpet_disable(); 644 #endif 645 646 #ifdef CONFIG_X86_64 647 x86_platform.iommu_shutdown(); 648 #endif 649 } 650 651 static void __machine_emergency_restart(int emergency) 652 { 653 reboot_emergency = emergency; 654 machine_ops.emergency_restart(); 655 } 656 657 static void native_machine_restart(char *__unused) 658 { 659 pr_notice("machine restart\n"); 660 661 if (!reboot_force) 662 machine_shutdown(); 663 __machine_emergency_restart(0); 664 } 665 666 static void native_machine_halt(void) 667 { 668 /* Stop other cpus and apics */ 669 machine_shutdown(); 670 671 tboot_shutdown(TB_SHUTDOWN_HALT); 672 673 stop_this_cpu(NULL); 674 } 675 676 static void native_machine_power_off(void) 677 { 678 if (pm_power_off) { 679 if (!reboot_force) 680 machine_shutdown(); 681 pm_power_off(); 682 } 683 /* A fallback in case there is no PM info available */ 684 tboot_shutdown(TB_SHUTDOWN_HALT); 685 } 686 687 struct machine_ops machine_ops = { 688 .power_off = native_machine_power_off, 689 .shutdown = native_machine_shutdown, 690 .emergency_restart = native_machine_emergency_restart, 691 .restart = native_machine_restart, 692 .halt = native_machine_halt, 693 #ifdef CONFIG_KEXEC_CORE 694 .crash_shutdown = native_machine_crash_shutdown, 695 #endif 696 }; 697 698 void machine_power_off(void) 699 { 700 machine_ops.power_off(); 701 } 702 703 void machine_shutdown(void) 704 { 705 machine_ops.shutdown(); 706 } 707 708 void machine_emergency_restart(void) 709 { 710 __machine_emergency_restart(1); 711 } 712 713 void machine_restart(char *cmd) 714 { 715 machine_ops.restart(cmd); 716 } 717 718 void machine_halt(void) 719 { 720 machine_ops.halt(); 721 } 722 723 #ifdef CONFIG_KEXEC_CORE 724 void machine_crash_shutdown(struct pt_regs *regs) 725 { 726 machine_ops.crash_shutdown(regs); 727 } 728 #endif 729 730 731 #if defined(CONFIG_SMP) 732 733 /* This keeps a track of which one is crashing cpu. */ 734 static int crashing_cpu; 735 static nmi_shootdown_cb shootdown_callback; 736 737 static atomic_t waiting_for_crash_ipi; 738 static int crash_ipi_issued; 739 740 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) 741 { 742 int cpu; 743 744 cpu = raw_smp_processor_id(); 745 746 /* 747 * Don't do anything if this handler is invoked on crashing cpu. 748 * Otherwise, system will completely hang. Crashing cpu can get 749 * an NMI if system was initially booted with nmi_watchdog parameter. 750 */ 751 if (cpu == crashing_cpu) 752 return NMI_HANDLED; 753 local_irq_disable(); 754 755 shootdown_callback(cpu, regs); 756 757 atomic_dec(&waiting_for_crash_ipi); 758 /* Assume hlt works */ 759 halt(); 760 for (;;) 761 cpu_relax(); 762 763 return NMI_HANDLED; 764 } 765 766 static void smp_send_nmi_allbutself(void) 767 { 768 apic->send_IPI_allbutself(NMI_VECTOR); 769 } 770 771 /* 772 * Halt all other CPUs, calling the specified function on each of them 773 * 774 * This function can be used to halt all other CPUs on crash 775 * or emergency reboot time. The function passed as parameter 776 * will be called inside a NMI handler on all CPUs. 777 */ 778 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 779 { 780 unsigned long msecs; 781 local_irq_disable(); 782 783 /* Make a note of crashing cpu. Will be used in NMI callback. */ 784 crashing_cpu = safe_smp_processor_id(); 785 786 shootdown_callback = callback; 787 788 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); 789 /* Would it be better to replace the trap vector here? */ 790 if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, 791 NMI_FLAG_FIRST, "crash")) 792 return; /* Return what? */ 793 /* 794 * Ensure the new callback function is set before sending 795 * out the NMI 796 */ 797 wmb(); 798 799 smp_send_nmi_allbutself(); 800 801 /* Kick CPUs looping in NMI context. */ 802 WRITE_ONCE(crash_ipi_issued, 1); 803 804 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 805 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 806 mdelay(1); 807 msecs--; 808 } 809 810 /* Leave the nmi callback set */ 811 } 812 813 /* 814 * Check if the crash dumping IPI got issued and if so, call its callback 815 * directly. This function is used when we have already been in NMI handler. 816 * It doesn't return. 817 */ 818 void run_crash_ipi_callback(struct pt_regs *regs) 819 { 820 if (crash_ipi_issued) 821 crash_nmi_callback(0, regs); 822 } 823 824 /* Override the weak function in kernel/panic.c */ 825 void nmi_panic_self_stop(struct pt_regs *regs) 826 { 827 while (1) { 828 /* If no CPU is preparing crash dump, we simply loop here. */ 829 run_crash_ipi_callback(regs); 830 cpu_relax(); 831 } 832 } 833 834 #else /* !CONFIG_SMP */ 835 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 836 { 837 /* No other CPUs to shoot down */ 838 } 839 840 void run_crash_ipi_callback(struct pt_regs *regs) 841 { 842 } 843 #endif 844