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 CompuLab SBC-FITPC2 */ 362 .callback = set_bios_reboot, 363 .ident = "CompuLab SBC-FITPC2", 364 .matches = { 365 DMI_MATCH(DMI_SYS_VENDOR, "CompuLab"), 366 DMI_MATCH(DMI_PRODUCT_NAME, "SBC-FITPC2"), 367 }, 368 }, 369 { /* Handle problems with rebooting on ASUS P4S800 */ 370 .callback = set_bios_reboot, 371 .ident = "ASUS P4S800", 372 .matches = { 373 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."), 374 DMI_MATCH(DMI_BOARD_NAME, "P4S800"), 375 }, 376 }, 377 378 { /* Handle reboot issue on Acer Aspire one */ 379 .callback = set_kbd_reboot, 380 .ident = "Acer Aspire One A110", 381 .matches = { 382 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 383 DMI_MATCH(DMI_PRODUCT_NAME, "AOA110"), 384 }, 385 }, 386 { /* Handle problems with rebooting on Apple MacBook5 */ 387 .callback = set_pci_reboot, 388 .ident = "Apple MacBook5", 389 .matches = { 390 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 391 DMI_MATCH(DMI_PRODUCT_NAME, "MacBook5"), 392 }, 393 }, 394 { /* Handle problems with rebooting on Apple MacBookPro5 */ 395 .callback = set_pci_reboot, 396 .ident = "Apple MacBookPro5", 397 .matches = { 398 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 399 DMI_MATCH(DMI_PRODUCT_NAME, "MacBookPro5"), 400 }, 401 }, 402 { /* Handle problems with rebooting on Apple Macmini3,1 */ 403 .callback = set_pci_reboot, 404 .ident = "Apple Macmini3,1", 405 .matches = { 406 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 407 DMI_MATCH(DMI_PRODUCT_NAME, "Macmini3,1"), 408 }, 409 }, 410 { /* Handle problems with rebooting on the iMac9,1. */ 411 .callback = set_pci_reboot, 412 .ident = "Apple iMac9,1", 413 .matches = { 414 DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."), 415 DMI_MATCH(DMI_PRODUCT_NAME, "iMac9,1"), 416 }, 417 }, 418 { /* Handle problems with rebooting on the Latitude E6320. */ 419 .callback = set_pci_reboot, 420 .ident = "Dell Latitude E6320", 421 .matches = { 422 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 423 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6320"), 424 }, 425 }, 426 { /* Handle problems with rebooting on the Latitude E5420. */ 427 .callback = set_pci_reboot, 428 .ident = "Dell Latitude E5420", 429 .matches = { 430 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 431 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E5420"), 432 }, 433 }, 434 { /* Handle problems with rebooting on the Latitude E6420. */ 435 .callback = set_pci_reboot, 436 .ident = "Dell Latitude E6420", 437 .matches = { 438 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 439 DMI_MATCH(DMI_PRODUCT_NAME, "Latitude E6420"), 440 }, 441 }, 442 { /* Handle problems with rebooting on the OptiPlex 990. */ 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, "OptiPlex 990"), 448 }, 449 }, 450 { /* Handle problems with rebooting on the Precision M6600. */ 451 .callback = set_pci_reboot, 452 .ident = "Dell OptiPlex 990", 453 .matches = { 454 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."), 455 DMI_MATCH(DMI_PRODUCT_NAME, "Precision M6600"), 456 }, 457 }, 458 { } 459 }; 460 461 static int __init reboot_init(void) 462 { 463 /* 464 * Only do the DMI check if reboot_type hasn't been overridden 465 * on the command line 466 */ 467 if (reboot_default) 468 dmi_check_system(reboot_dmi_table); 469 return 0; 470 } 471 core_initcall(reboot_init); 472 473 static inline void kb_wait(void) 474 { 475 int i; 476 477 for (i = 0; i < 0x10000; i++) { 478 if ((inb(0x64) & 0x02) == 0) 479 break; 480 udelay(2); 481 } 482 } 483 484 static void vmxoff_nmi(int cpu, struct pt_regs *regs) 485 { 486 cpu_emergency_vmxoff(); 487 } 488 489 /* Use NMIs as IPIs to tell all CPUs to disable virtualization */ 490 static void emergency_vmx_disable_all(void) 491 { 492 /* Just make sure we won't change CPUs while doing this */ 493 local_irq_disable(); 494 495 /* 496 * We need to disable VMX on all CPUs before rebooting, otherwise 497 * we risk hanging up the machine, because the CPU ignore INIT 498 * signals when VMX is enabled. 499 * 500 * We can't take any locks and we may be on an inconsistent 501 * state, so we use NMIs as IPIs to tell the other CPUs to disable 502 * VMX and halt. 503 * 504 * For safety, we will avoid running the nmi_shootdown_cpus() 505 * stuff unnecessarily, but we don't have a way to check 506 * if other CPUs have VMX enabled. So we will call it only if the 507 * CPU we are running on has VMX enabled. 508 * 509 * We will miss cases where VMX is not enabled on all CPUs. This 510 * shouldn't do much harm because KVM always enable VMX on all 511 * CPUs anyway. But we can miss it on the small window where KVM 512 * is still enabling VMX. 513 */ 514 if (cpu_has_vmx() && cpu_vmx_enabled()) { 515 /* Disable VMX on this CPU. */ 516 cpu_vmxoff(); 517 518 /* Halt and disable VMX on the other CPUs */ 519 nmi_shootdown_cpus(vmxoff_nmi); 520 521 } 522 } 523 524 525 void __attribute__((weak)) mach_reboot_fixups(void) 526 { 527 } 528 529 /* 530 * Windows compatible x86 hardware expects the following on reboot: 531 * 532 * 1) If the FADT has the ACPI reboot register flag set, try it 533 * 2) If still alive, write to the keyboard controller 534 * 3) If still alive, write to the ACPI reboot register again 535 * 4) If still alive, write to the keyboard controller again 536 * 537 * If the machine is still alive at this stage, it gives up. We default to 538 * following the same pattern, except that if we're still alive after (4) we'll 539 * try to force a triple fault and then cycle between hitting the keyboard 540 * controller and doing that 541 */ 542 static void native_machine_emergency_restart(void) 543 { 544 int i; 545 int attempt = 0; 546 int orig_reboot_type = reboot_type; 547 548 if (reboot_emergency) 549 emergency_vmx_disable_all(); 550 551 tboot_shutdown(TB_SHUTDOWN_REBOOT); 552 553 /* Tell the BIOS if we want cold or warm reboot */ 554 *((unsigned short *)__va(0x472)) = reboot_mode; 555 556 for (;;) { 557 /* Could also try the reset bit in the Hammer NB */ 558 switch (reboot_type) { 559 case BOOT_KBD: 560 mach_reboot_fixups(); /* For board specific fixups */ 561 562 for (i = 0; i < 10; i++) { 563 kb_wait(); 564 udelay(50); 565 outb(0xfe, 0x64); /* Pulse reset low */ 566 udelay(50); 567 } 568 if (attempt == 0 && orig_reboot_type == BOOT_ACPI) { 569 attempt = 1; 570 reboot_type = BOOT_ACPI; 571 } else { 572 reboot_type = BOOT_TRIPLE; 573 } 574 break; 575 576 case BOOT_TRIPLE: 577 load_idt(&no_idt); 578 __asm__ __volatile__("int3"); 579 580 reboot_type = BOOT_KBD; 581 break; 582 583 case BOOT_BIOS: 584 machine_real_restart(MRR_BIOS); 585 586 reboot_type = BOOT_KBD; 587 break; 588 589 case BOOT_ACPI: 590 acpi_reboot(); 591 reboot_type = BOOT_KBD; 592 break; 593 594 case BOOT_EFI: 595 if (efi_enabled) 596 efi.reset_system(reboot_mode ? 597 EFI_RESET_WARM : 598 EFI_RESET_COLD, 599 EFI_SUCCESS, 0, NULL); 600 reboot_type = BOOT_KBD; 601 break; 602 603 case BOOT_CF9: 604 port_cf9_safe = true; 605 /* Fall through */ 606 607 case BOOT_CF9_COND: 608 if (port_cf9_safe) { 609 u8 cf9 = inb(0xcf9) & ~6; 610 outb(cf9|2, 0xcf9); /* Request hard reset */ 611 udelay(50); 612 outb(cf9|6, 0xcf9); /* Actually do the reset */ 613 udelay(50); 614 } 615 reboot_type = BOOT_KBD; 616 break; 617 } 618 } 619 } 620 621 void native_machine_shutdown(void) 622 { 623 /* Stop the cpus and apics */ 624 #ifdef CONFIG_SMP 625 626 /* The boot cpu is always logical cpu 0 */ 627 int reboot_cpu_id = 0; 628 629 /* See if there has been given a command line override */ 630 if ((reboot_cpu != -1) && (reboot_cpu < nr_cpu_ids) && 631 cpu_online(reboot_cpu)) 632 reboot_cpu_id = reboot_cpu; 633 634 /* Make certain the cpu I'm about to reboot on is online */ 635 if (!cpu_online(reboot_cpu_id)) 636 reboot_cpu_id = smp_processor_id(); 637 638 /* Make certain I only run on the appropriate processor */ 639 set_cpus_allowed_ptr(current, cpumask_of(reboot_cpu_id)); 640 641 /* 642 * O.K Now that I'm on the appropriate processor, stop all of the 643 * others. Also disable the local irq to not receive the per-cpu 644 * timer interrupt which may trigger scheduler's load balance. 645 */ 646 local_irq_disable(); 647 stop_other_cpus(); 648 #endif 649 650 lapic_shutdown(); 651 652 #ifdef CONFIG_X86_IO_APIC 653 disable_IO_APIC(); 654 #endif 655 656 #ifdef CONFIG_HPET_TIMER 657 hpet_disable(); 658 #endif 659 660 #ifdef CONFIG_X86_64 661 x86_platform.iommu_shutdown(); 662 #endif 663 } 664 665 static void __machine_emergency_restart(int emergency) 666 { 667 reboot_emergency = emergency; 668 machine_ops.emergency_restart(); 669 } 670 671 static void native_machine_restart(char *__unused) 672 { 673 pr_notice("machine restart\n"); 674 675 if (!reboot_force) 676 machine_shutdown(); 677 __machine_emergency_restart(0); 678 } 679 680 static void native_machine_halt(void) 681 { 682 /* Stop other cpus and apics */ 683 machine_shutdown(); 684 685 tboot_shutdown(TB_SHUTDOWN_HALT); 686 687 stop_this_cpu(NULL); 688 } 689 690 static void native_machine_power_off(void) 691 { 692 if (pm_power_off) { 693 if (!reboot_force) 694 machine_shutdown(); 695 pm_power_off(); 696 } 697 /* A fallback in case there is no PM info available */ 698 tboot_shutdown(TB_SHUTDOWN_HALT); 699 } 700 701 struct machine_ops machine_ops = { 702 .power_off = native_machine_power_off, 703 .shutdown = native_machine_shutdown, 704 .emergency_restart = native_machine_emergency_restart, 705 .restart = native_machine_restart, 706 .halt = native_machine_halt, 707 #ifdef CONFIG_KEXEC 708 .crash_shutdown = native_machine_crash_shutdown, 709 #endif 710 }; 711 712 void machine_power_off(void) 713 { 714 machine_ops.power_off(); 715 } 716 717 void machine_shutdown(void) 718 { 719 machine_ops.shutdown(); 720 } 721 722 void machine_emergency_restart(void) 723 { 724 __machine_emergency_restart(1); 725 } 726 727 void machine_restart(char *cmd) 728 { 729 machine_ops.restart(cmd); 730 } 731 732 void machine_halt(void) 733 { 734 machine_ops.halt(); 735 } 736 737 #ifdef CONFIG_KEXEC 738 void machine_crash_shutdown(struct pt_regs *regs) 739 { 740 machine_ops.crash_shutdown(regs); 741 } 742 #endif 743 744 745 #if defined(CONFIG_SMP) 746 747 /* This keeps a track of which one is crashing cpu. */ 748 static int crashing_cpu; 749 static nmi_shootdown_cb shootdown_callback; 750 751 static atomic_t waiting_for_crash_ipi; 752 753 static int crash_nmi_callback(unsigned int val, struct pt_regs *regs) 754 { 755 int cpu; 756 757 cpu = raw_smp_processor_id(); 758 759 /* 760 * Don't do anything if this handler is invoked on crashing cpu. 761 * Otherwise, system will completely hang. Crashing cpu can get 762 * an NMI if system was initially booted with nmi_watchdog parameter. 763 */ 764 if (cpu == crashing_cpu) 765 return NMI_HANDLED; 766 local_irq_disable(); 767 768 shootdown_callback(cpu, regs); 769 770 atomic_dec(&waiting_for_crash_ipi); 771 /* Assume hlt works */ 772 halt(); 773 for (;;) 774 cpu_relax(); 775 776 return NMI_HANDLED; 777 } 778 779 static void smp_send_nmi_allbutself(void) 780 { 781 apic->send_IPI_allbutself(NMI_VECTOR); 782 } 783 784 /* 785 * Halt all other CPUs, calling the specified function on each of them 786 * 787 * This function can be used to halt all other CPUs on crash 788 * or emergency reboot time. The function passed as parameter 789 * will be called inside a NMI handler on all CPUs. 790 */ 791 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 792 { 793 unsigned long msecs; 794 local_irq_disable(); 795 796 /* Make a note of crashing cpu. Will be used in NMI callback. */ 797 crashing_cpu = safe_smp_processor_id(); 798 799 shootdown_callback = callback; 800 801 atomic_set(&waiting_for_crash_ipi, num_online_cpus() - 1); 802 /* Would it be better to replace the trap vector here? */ 803 if (register_nmi_handler(NMI_LOCAL, crash_nmi_callback, 804 NMI_FLAG_FIRST, "crash")) 805 return; /* Return what? */ 806 /* 807 * Ensure the new callback function is set before sending 808 * out the NMI 809 */ 810 wmb(); 811 812 smp_send_nmi_allbutself(); 813 814 msecs = 1000; /* Wait at most a second for the other cpus to stop */ 815 while ((atomic_read(&waiting_for_crash_ipi) > 0) && msecs) { 816 mdelay(1); 817 msecs--; 818 } 819 820 /* Leave the nmi callback set */ 821 } 822 #else /* !CONFIG_SMP */ 823 void nmi_shootdown_cpus(nmi_shootdown_cb callback) 824 { 825 /* No other CPUs to shoot down */ 826 } 827 #endif 828