arch/x86/kernel/reboot.c

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