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