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