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