Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/arch/x86/kernel/reboot.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us