1 #include <linux/module.h> 2 #include <linux/reboot.h> 3 #include <linux/init.h> 4 #include <linux/pm.h> 5 #include <linux/efi.h> 6 #include <linux/dmi.h> 7 #include <linux/sched.h> 8 #include <linux/tboot.h> 9 #include <linux/delay.h> 10 #include <acpi/reboot.h> 11 #include <asm/io.h> 12 #include <asm/apic.h> 13 #include <asm/desc.h> 14 #include <asm/hpet.h> 15 #include <asm/pgtable.h> 16 #include <asm/proto.h> 17 #include <asm/reboot_fixups.h> 18 #include <asm/reboot.h> 19 #include <asm/pci_x86.h> 20 #include <asm/virtext.h> 21 #include <asm/cpu.h> 22 #include <asm/nmi.h> 23 24 #ifdef CONFIG_X86_32 25 # include <linux/ctype.h> 26 # include <linux/mc146818rtc.h> 27 # include <asm/realmode.h> 28 #else 29 # include <asm/x86_init.h> 30 #endif 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 static int reboot_mode; 40 enum reboot_type reboot_type = BOOT_ACPI; 41 int reboot_force; 42 43 /* 44 * This variable is used privately to keep track of whether or not 45 * reboot_type is still set to its default value (i.e., reboot= hasn't 46 * been set on the command line). This is needed so that we can 47 * suppress DMI scanning for reboot quirks. Without it, it's 48 * impossible to override a faulty reboot quirk without recompiling. 49 */ 50 static int reboot_default = 1; 51 52 #if defined(CONFIG_X86_32) && defined(CONFIG_SMP) 53 static int reboot_cpu = -1; 54 #endif 55 56 /* 57 * This is set if we need to go through the 'emergency' path. 58 * When machine_emergency_restart() is called, we may be on 59 * an inconsistent state and won't be able to do a clean cleanup 60 */ 61 static int reboot_emergency; 62 63 /* This is set by the PCI code if either type 1 or type 2 PCI is detected */ 64 bool port_cf9_safe = false; 65 66 /* 67 * reboot=b[ios] | s[mp] | t[riple] | k[bd] | e[fi] [, [w]arm | [c]old] | p[ci] 68 * warm Don't set the cold reboot flag 69 * cold Set the cold reboot flag 70 * bios Reboot by jumping through the BIOS (only for X86_32) 71 * smp Reboot by executing reset on BSP or other CPU (only for X86_32) 72 * triple Force a triple fault (init) 73 * kbd Use the keyboard controller. cold reset (default) 74 * acpi Use the RESET_REG in the FADT 75 * efi Use efi reset_system runtime service 76 * pci Use the so-called "PCI reset register", CF9 77 * force Avoid anything that could hang. 78 */ 79 static int __init reboot_setup(char *str) 80 { 81 for (;;) { 82 /* 83 * Having anything passed on the command line via 84 * reboot= will cause us to disable DMI checking 85 * below. 86 */ 87 reboot_default = 0; 88 89 switch (*str) { 90 case 'w': 91 reboot_mode = 0x1234; 92 break; 93 94 case 'c': 95 reboot_mode = 0; 96 break; 97 98 #ifdef CONFIG_X86_32 99 #ifdef CONFIG_SMP 100 case 's': 101 if (isdigit(*(str+1))) { 102 reboot_cpu = (int) (*(str+1) - '0'); 103 if (isdigit(*(str+2))) 104 reboot_cpu = reboot_cpu*10 + (int)(*(str+2) - '0'); 105 } 106 /* 107 * We will leave sorting out the final value 108 * when we are ready to reboot, since we might not 109 * have detected BSP APIC ID or smp_num_cpu 110 */ 111 break; 112 #endif /* CONFIG_SMP */ 113 114 case 'b': 115 #endif 116 case 'a': 117 case 'k': 118 case 't': 119 case 'e': 120 case 'p': 121 reboot_type = *str; 122 break; 123 124 case 'f': 125 reboot_force = 1; 126 break; 127 } 128 129 str = strchr(str, ','); 130 if (str) 131 str++; 132 else 133 break; 134 } 135 return 1; 136 } 137 138 __setup("reboot=", reboot_setup); 139 140 141 #ifdef CONFIG_X86_32 142 /* 143 * Reboot options and system auto-detection code provided by 144 * Dell Inc. so their systems "just work". :-) 145 */ 146 147 /* 148 * Some machines require the "reboot=b" or "reboot=k" commandline options, 149 * this quirk makes that automatic. 150 */ 151 static int __init set_bios_reboot(const struct dmi_system_id *d) 152 { 153 if (reboot_type != BOOT_BIOS) { 154 reboot_type = BOOT_BIOS; 155 printk(KERN_INFO "%s series board detected. Selecting BIOS-method for reboots.\n", d->ident); 156 } 157 return 0; 158 } 159 160 void machine_real_restart(unsigned int type) 161 { 162 void (*restart_lowmem)(unsigned int) = (void (*)(unsigned int)) 163 real_mode_header->machine_real_restart_asm; 164 165 local_irq_disable(); 166 167 /* 168 * Write zero to CMOS register number 0x0f, which the BIOS POST 169 * routine will recognize as telling it to do a proper reboot. (Well 170 * that's what this book in front of me says -- it may only apply to 171 * the Phoenix BIOS though, it's not clear). At the same time, 172 * disable NMIs by setting the top bit in the CMOS address register, 173 * as we're about to do peculiar things to the CPU. I'm not sure if 174 * `outb_p' is needed instead of just `outb'. Use it to be on the 175 * safe side. (Yes, CMOS_WRITE does outb_p's. - Paul G.) 176 */ 177 spin_lock(&rtc_lock); 178 CMOS_WRITE(0x00, 0x8f); 179 spin_unlock(&rtc_lock); 180 181 /* 182 * Switch back to the initial page table. 183 */ 184 load_cr3(initial_page_table); 185 186 /* 187 * Write 0x1234 to absolute memory location 0x472. The BIOS reads 188 * this on booting to tell it to "Bypass memory test (also warm 189 * boot)". This seems like a fairly standard thing that gets set by 190 * REBOOT.COM programs, and the previous reset routine did this 191 * too. */ 192 *((unsigned short *)0x472) = reboot_mode; 193 194 /* Jump to the identity-mapped low memory code */ 195 restart_lowmem(type); 196 } 197 #ifdef CONFIG_APM_MODULE 198 EXPORT_SYMBOL(machine_real_restart); 199 #endif 200 201 #endif /* CONFIG_X86_32 */ 202 203 /* 204 * Some Apple MacBook and MacBookPro's needs reboot=p to be able to reboot 205 */ 206 static int __init set_pci_reboot(const struct dmi_system_id *d) 207 { 208 if (reboot_type != BOOT_CF9) { 209 reboot_type = BOOT_CF9; 210 printk(KERN_INFO "%s series board detected. " 211 "Selecting PCI-method for reboots.\n", d->ident); 212 } 213 return 0; 214 } 215 216 static int __init set_kbd_reboot(const struct dmi_system_id *d) 217 { 218 if (reboot_type != BOOT_KBD) { 219 reboot_type = BOOT_KBD; 220 printk(KERN_INFO "%s series board detected. Selecting KBD-method for reboot.\n", d->ident); 221 } 222 return 0; 223 } 224 225 /* 226 * This is a single dmi_table handling all reboot quirks. Note that 227 * REBOOT_BIOS is only available for 32bit 228 */ 229 static struct dmi_system_id __initdata reboot_dmi_table[] = { 230 #ifdef CONFIG_X86_32 231 { /* Handle problems with rebooting on Dell E520's */ 232 .callback = set_bios_reboot, 233 .ident = "Dell E520", 234 .matches = { 235 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 236 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DM061"), 237 }, 238 }, 239 { /* Handle problems with rebooting on Dell 1300's */ 240 .callback = set_bios_reboot, 241 .ident = "Dell PowerEdge 1300", 242 .matches = { 243 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 244 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 1300/"), 245 }, 246 }, 247 { /* Handle problems with rebooting on Dell 300's */ 248 .callback = set_bios_reboot, 249 .ident = "Dell PowerEdge 300", 250 .matches = { 251 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 252 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"), 253 }, 254 }, 255 { /* Handle problems with rebooting on Dell Optiplex 745's SFF */ 256 .callback = set_bios_reboot, 257 .ident = "Dell OptiPlex 745", 258 .matches = { 259 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 260 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 261 }, 262 }, 263 { /* Handle problems with rebooting on Dell Optiplex 745's DFF */ 264 .callback = set_bios_reboot, 265 .ident = "Dell OptiPlex 745", 266 .matches = { 267 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 268 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 269 DMI_MATCH(DMI_BOARD_NAME, "0MM599"), 270 }, 271 }, 272 { /* Handle problems with rebooting on Dell Optiplex 745 with 0KW626 */ 273 .callback = set_bios_reboot, 274 .ident = "Dell OptiPlex 745", 275 .matches = { 276 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 277 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"), 278 DMI_MATCH(DMI_BOARD_NAME, "0KW626"), 279 }, 280 }, 281 { /* Handle problems with rebooting on Dell Optiplex 330 with 0KP561 */ 282 .callback = set_bios_reboot, 283 .ident = "Dell OptiPlex 330", 284 .matches = { 285 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 286 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 330"), 287 DMI_MATCH(DMI_BOARD_NAME, "0KP561"), 288 }, 289 }, 290 { /* Handle problems with rebooting on Dell Optiplex 360 with 0T656F */ 291 .callback = set_bios_reboot, 292 .ident = "Dell OptiPlex 360", 293 .matches = { 294 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 295 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 360"), 296 DMI_MATCH(DMI_BOARD_NAME, "0T656F"), 297 }, 298 }, 299 { /* Handle problems with rebooting on Dell OptiPlex 760 with 0G919G */ 300 .callback = set_bios_reboot, 301 .ident = "Dell OptiPlex 760", 302 .matches = { 303 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 304 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 760"), 305 DMI_MATCH(DMI_BOARD_NAME, "0G919G"), 306 }, 307 }, 308 { /* Handle problems with rebooting on Dell 2400's */ 309 .callback = set_bios_reboot, 310 .ident = "Dell PowerEdge 2400", 311 .matches = { 312 DMI_MATCH(DMI_SYS_VENDOR, "Dell Computer Corporation"), 313 DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 2400"), 314 }, 315 }, 316 { /* Handle problems with rebooting on Dell T5400's */ 317 .callback = set_bios_reboot, 318 .ident = "Dell Precision T5400", 319 .matches = { 320 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 321 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T5400"), 322 }, 323 }, 324 { /* Handle problems with rebooting on Dell T7400's */ 325 .callback = set_bios_reboot, 326 .ident = "Dell Precision T7400", 327 .matches = { 328 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 329 DMI_MATCH(DMI_PRODUCT_NAME, "Precision WorkStation T7400"), 330 }, 331 }, 332 { /* Handle problems with rebooting on HP laptops */ 333 .callback = set_bios_reboot, 334 .ident = "HP Compaq Laptop", 335 .matches = { 336 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 337 DMI_MATCH(DMI_PRODUCT_NAME, "HP Compaq"), 338 }, 339 }, 340 { /* Handle problems with rebooting on Dell XPS710 */ 341 .callback = set_bios_reboot, 342 .ident = "Dell XPS710", 343 .matches = { 344 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 345 DMI_MATCH(DMI_PRODUCT_NAME, "Dell XPS710"), 346 }, 347 }, 348 { /* Handle problems with rebooting on Dell DXP061 */ 349 .callback = set_bios_reboot, 350 .ident = "Dell DXP061", 351 .matches = { 352 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 353 DMI_MATCH(DMI_PRODUCT_NAME, "Dell DXP061"), 354 }, 355 }, 356 { /* Handle problems with rebooting on Sony VGN-Z540N */ 357 .callback = set_bios_reboot, 358 .ident = "Sony VGN-Z540N", 359 .matches = { 360 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"), 361 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-Z540N"), 362 }, 363 }, 364 { /* Handle problems with rebooting on CompuLab SBC-FITPC2 */ 365 .callback = set_bios_reboot, 366 .ident = "CompuLab SBC-FITPC2", 367 .matches = { 368 DMI_MATCH(DMI_SYS_VENDOR, "CompuLab"), 369 DMI_MATCH(DMI_PRODUCT_NAME, "SBC-FITPC2"), 370 }, 371 }, 372 { /* Handle problems with rebooting on ASUS P4S800 */ 373 .callback = set_bios_reboot, 374 .ident = "ASUS P4S800", 375 .matches = { 376 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 377 DMI_MATCH(DMI_BOARD_NAME, "P4S800"), 378 }, 379 }, 380 #endif /* CONFIG_X86_32 */ 381 382 { /* Handle reboot issue on Acer Aspire one */ 383 .callback = set_kbd_reboot, 384 .ident = "Acer Aspire One A110", 385 .matches = { 386 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 387 DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"), 388 }, 389 }, 390 { /* Handle problems with rebooting on Apple MacBook5 */ 391 .callback = set_pci_reboot, 392 .ident = "Apple MacBook5", 393 .matches = { 394 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 395 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5"), 396 }, 397 }, 398 { /* Handle problems with rebooting on Apple MacBookPro5 */ 399 .callback = set_pci_reboot, 400 .ident = "Apple MacBookPro5", 401 .matches = { 402 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 403 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5"), 404 }, 405 }, 406 { /* Handle problems with rebooting on Apple Macmini3,1 */ 407 .callback = set_pci_reboot, 408 .ident = "Apple Macmini3,1", 409 .matches = { 410 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 411 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini3,1"), 412 }, 413 }, 414 { /* Handle problems with rebooting on the iMac9,1. */ 415 .callback = set_pci_reboot, 416 .ident = "Apple iMac9,1", 417 .matches = { 418 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 419 DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1"), 420 }, 421 }, 422 { /* Handle problems with rebooting on the Latitude E6320. */ 423 .callback = set_pci_reboot, 424 .ident = "Dell Latitude E6320", 425 .matches = { 426 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 427 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"), 428 }, 429 }, 430 { /* Handle problems with rebooting on the Latitude E5420. */ 431 .callback = set_pci_reboot, 432 .ident = "Dell Latitude E5420", 433 .matches = { 434 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 435 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"), 436 }, 437 }, 438 { /* Handle problems with rebooting on the Latitude E6420. */ 439 .callback = set_pci_reboot, 440 .ident = "Dell Latitude E6420", 441 .matches = { 442 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 443 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"), 444 }, 445 }, 446 { /* Handle problems with rebooting on the OptiPlex 990. */ 447 .callback = set_pci_reboot, 448 .ident = "Dell OptiPlex 990", 449 .matches = { 450 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 451 DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 990"), 452 }, 453 }, 454 { /* Handle problems with rebooting on the Precision M6600. */ 455 .callback = set_pci_reboot, 456 .ident = "Dell OptiPlex 990", 457 .matches = { 458 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 459 DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"), 460 }, 461 }, 462 { } 463 }; 464 465 static int __init reboot_init(void) 466 { 467 /* 468 * Only do the DMI check if reboot_type hasn't been overridden 469 * on the command line 470 */ 471 if (reboot_default) 472 dmi_check_system(reboot_dmi_table); 473 return 0; 474 } 475 core_initcall(reboot_init); 476 477 static inline void kb_wait(void) 478 { 479 int i; 480 481 for (i = 0; i < 0x10000; i++) { 482 if ((inb(0x64) & 0x02) == 0) 483 break; 484 udelay(2); 485 } 486 } 487 488 static void vmxoff_nmi(int cpu, struct pt_regs *regs) 489 { 490 cpu_emergency_vmxoff(); 491 } 492 493 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ 494 static void emergency_vmx_disable_all(void) 495 { 496 /* Just make sure we won't change CPUs while doing this */ 497 local_irq_disable(); 498 499 /* 500 * We need to disable VMX on all CPUs before rebooting, otherwise 501 * we risk hanging up the machine, because the CPU ignore INIT 502 * signals when VMX is enabled. 503 * 504 * We can't take any locks and we may be on an inconsistent 505 * state, so we use NMIs as IPIs to tell the other CPUs to disable 506 * VMX and halt. 507 * 508 * For safety, we will avoid running the nmi_shootdown_cpus() 509 * stuff unnecessarily, but we don't have a way to check 510 * if other CPUs have VMX enabled. So we will call it only if the 511 * CPU we are running on has VMX enabled. 512 * 513 * We will miss cases where VMX is not enabled on all CPUs. This 514 * shouldn't do much harm because KVM always enable VMX on all 515 * CPUs anyway. But we can miss it on the small window where KVM 516 * is still enabling VMX. 517 */ 518 if (cpu_has_vmx() && cpu_vmx_enabled()) { 519 /* Disable VMX on this CPU. */ 520 cpu_vmxoff(); 521 522 /* Halt and disable VMX on the other CPUs */ 523 nmi_shootdown_cpus(vmxoff_nmi); 524 525 } 526 } 527 528 529 void __attribute__((weak)) mach_reboot_fixups(void) 530 { 531 } 532 533 /* 534 * Windows compatible x86 hardware expects the following on reboot: 535 * 536 * 1) If the FADT has the ACPI reboot register flag set, try it 537 * 2) If still alive, write to the keyboard controller 538 * 3) If still alive, write to the ACPI reboot register again 539 * 4) If still alive, write to the keyboard controller again 540 * 541 * If the machine is still alive at this stage, it gives up. We default to 542 * following the same pattern, except that if we're still alive after (4) we'll 543 * try to force a triple fault and then cycle between hitting the keyboard 544 * controller and doing that 545 */ 546 static void native_machine_emergency_restart(void) 547 { 548 int i; 549 int attempt = 0; 550 int orig_reboot_type = reboot_type; 551 552 if (reboot_emergency) 553 emergency_vmx_disable_all(); 554 555 tboot_shutdown(TB_SHUTDOWN_REBOOT); 556 557 /* Tell the BIOS if we want cold or warm reboot */ 558 *((unsigned short *)__va(0x472)) = reboot_mode; 559 560 for (;;) { 561 /* Could also try the reset bit in the Hammer NB */ 562 switch (reboot_type) { 563 case BOOT_KBD: 564 mach_reboot_fixups(); /* For board specific fixups */ 565 566 for (i = 0; i < 10; i++) { 567 kb_wait(); 568 udelay(50); 569 outb(0xfe, 0x64); /* Pulse reset low */ 570 udelay(50); 571 } 572 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 573 attempt = 1; 574 reboot_type = BOOT_ACPI; 575 } else { 576 reboot_type = BOOT_TRIPLE; 577 } 578 break; 579 580 case BOOT_TRIPLE: 581 load_idt(&no_idt); 582 __asm__ __volatile__("int3"); 583 584 reboot_type = BOOT_KBD; 585 break; 586 587 #ifdef CONFIG_X86_32 588 case BOOT_BIOS: 589 machine_real_restart(MRR_BIOS); 590 591 reboot_type = BOOT_KBD; 592 break; 593 #endif 594 595 case BOOT_ACPI: 596 acpi_reboot(); 597 reboot_type = BOOT_KBD; 598 break; 599 600 case BOOT_EFI: 601 if (efi_enabled) 602 efi.reset_system(reboot_mode ? 603 EFI_RESET_WARM : 604 EFI_RESET_COLD, 605 EFI_SUCCESS, 0, NULL); 606 reboot_type = BOOT_KBD; 607 break; 608 609 case BOOT_CF9: 610 port_cf9_safe = true; 611 /* Fall through */ 612 613 case BOOT_CF9_COND: 614 if (port_cf9_safe) { 615 u8 cf9 = inb(0xcf9) & ~6; 616 outb(cf9|2, 0xcf9); /* Request hard reset */ 617 udelay(50); 618 outb(cf9|6, 0xcf9); /* Actually do the reset */ 619 udelay(50); 620 } 621 reboot_type = BOOT_KBD; 622 break; 623 } 624 } 625 } 626 627 void native_machine_shutdown(void) 628 { 629 /* Stop the cpus and apics */ 630 #ifdef CONFIG_SMP 631 632 /* The boot cpu is always logical cpu 0 */ 633 int reboot_cpu_id = 0; 634 635 #ifdef CONFIG_X86_32 636 /* See if there has been given a command line override */ 637 if ((reboot_cpu != -1) && (reboot_cpu < nr_cpu_ids) && 638 cpu_online(reboot_cpu)) 639 reboot_cpu_id = reboot_cpu; 640 #endif 641 642 /* Make certain the cpu I'm about to reboot on is online */ 643 if (!cpu_online(reboot_cpu_id)) 644 reboot_cpu_id = smp_processor_id(); 645 646 /* Make certain I only run on the appropriate processor */ 647 set_cpus_allowed_ptr(current, cpumask_of(reboot_cpu_id)); 648 649 /* 650 * O.K Now that I'm on the appropriate processor, stop all of the 651 * others. Also disable the local irq to not receive the per-cpu 652 * timer interrupt which may trigger scheduler's load balance. 653 */ 654 local_irq_disable(); 655 stop_other_cpus(); 656 #endif 657 658 lapic_shutdown(); 659 660 #ifdef CONFIG_X86_IO_APIC 661 disable_IO_APIC(); 662 #endif 663 664 #ifdef CONFIG_HPET_TIMER 665 hpet_disable(); 666 #endif 667 668 #ifdef CONFIG_X86_64 669 x86_platform.iommu_shutdown(); 670 #endif 671 } 672 673 static void __machine_emergency_restart(int emergency) 674 { 675 reboot_emergency = emergency; 676 machine_ops.emergency_restart(); 677 } 678 679 static void native_machine_restart(char *__unused) 680 { 681 printk("machine restart\n"); 682 683 if (!reboot_force) 684 machine_shutdown(); 685 __machine_emergency_restart(0); 686 } 687 688 static void native_machine_halt(void) 689 { 690 /* Stop other cpus and apics */ 691 machine_shutdown(); 692 693 tboot_shutdown(TB_SHUTDOWN_HALT); 694 695 stop_this_cpu(NULL); 696 } 697 698 static void native_machine_power_off(void) 699 { 700 if (pm_power_off) { 701 if (!reboot_force) 702 machine_shutdown(); 703 pm_power_off(); 704 } 705 /* A fallback in case there is no PM info available */ 706 tboot_shutdown(TB_SHUTDOWN_HALT); 707 } 708 709 struct machine_ops machine_ops = { 710 .power_off = native_machine_power_off, 711 .shutdown = native_machine_shutdown, 712 .emergency_restart = native_machine_emergency_restart, 713 .restart = native_machine_restart, 714 .halt = native_machine_halt, 715 #ifdef CONFIG_KEXEC 716 .crash_shutdown = native_machine_crash_shutdown, 717 #endif 718 }; 719 720 void machine_power_off(void) 721 { 722 machine_ops.power_off(); 723 } 724 725 void machine_shutdown(void) 726 { 727 machine_ops.shutdown(); 728 } 729 730 void machine_emergency_restart(void) 731 { 732 __machine_emergency_restart(1); 733 } 734 735 void machine_restart(char *cmd) 736 { 737 machine_ops.restart(cmd); 738 } 739 740 void machine_halt(void) 741 { 742 machine_ops.halt(); 743 } 744 745 #ifdef CONFIG_KEXEC 746 void machine_crash_shutdown(struct pt_regs *regs) 747 { 748 machine_ops.crash_shutdown(regs); 749 } 750 #endif 751 752 753 #if defined(CONFIG_SMP) 754 755 /* This keeps a track of which one is crashing cpu. */ 756 static int crashing_cpu; 757 static nmi_shootdown_cb shootdown_callback; 758 759 static atomic_t waiting_for_crash_ipi; 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 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 823 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 824 mdelay(1); 825 msecs--; 826 } 827 828 /* Leave the nmi callback set */ 829 } 830 #else /* !CONFIG_SMP */ 831 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 832 { 833 /* No other CPUs to shoot down */ 834 } 835 #endif 836