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