2 * Machine check exception handling CPU-side for power7 and power8
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 * Copyright 2013 IBM Corporation
19 * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com>
23 #define pr_fmt(fmt) "mce_power: " fmt
25 #include <linux/types.h>
26 #include <linux/ptrace.h>
29 #include <asm/machdep.h>
31 static void flush_tlb_206(unsigned int num_sets, unsigned int action)
37 case TLB_INVAL_SCOPE_GLOBAL:
38 rb = TLBIEL_INVAL_SET;
40 case TLB_INVAL_SCOPE_LPID:
41 rb = TLBIEL_INVAL_SET_LPID;
48 asm volatile("ptesync" : : : "memory");
49 for (i = 0; i < num_sets; i++) {
50 asm volatile("tlbiel %0" : : "r" (rb));
51 rb += 1 << TLBIEL_INVAL_SET_SHIFT;
53 asm volatile("ptesync" : : : "memory");
57 * Generic routines to flush TLB on POWER processors. These routines
58 * are used as flush_tlb hook in the cpu_spec.
60 * action => TLB_INVAL_SCOPE_GLOBAL: Invalidate all TLBs.
61 * TLB_INVAL_SCOPE_LPID: Invalidate TLB for current LPID.
63 void __flush_tlb_power7(unsigned int action)
65 flush_tlb_206(POWER7_TLB_SETS, action);
68 void __flush_tlb_power8(unsigned int action)
70 flush_tlb_206(POWER8_TLB_SETS, action);
73 void __flush_tlb_power9(unsigned int action)
75 unsigned int num_sets;
78 num_sets = POWER9_TLB_SETS_RADIX;
80 num_sets = POWER9_TLB_SETS_HASH;
82 flush_tlb_206(num_sets, action);
86 /* flush SLBs and reload */
87 #ifdef CONFIG_PPC_STD_MMU_64
88 static void flush_and_reload_slb(void)
90 struct slb_shadow *slb;
93 /* Invalidate all SLBs */
94 asm volatile("slbmte %0,%0; slbia" : : "r" (0));
96 #ifdef CONFIG_KVM_BOOK3S_HANDLER
98 * If machine check is hit when in guest or in transition, we will
99 * only flush the SLBs and continue.
101 if (get_paca()->kvm_hstate.in_guest)
105 /* For host kernel, reload the SLBs from shadow SLB buffer. */
106 slb = get_slb_shadow();
110 n = min_t(u32, be32_to_cpu(slb->persistent), SLB_MIN_SIZE);
112 /* Load up the SLB entries from shadow SLB */
113 for (i = 0; i < n; i++) {
114 unsigned long rb = be64_to_cpu(slb->save_area[i].esid);
115 unsigned long rs = be64_to_cpu(slb->save_area[i].vsid);
117 rb = (rb & ~0xFFFul) | i;
118 asm volatile("slbmte %0,%1" : : "r" (rs), "r" (rb));
123 static void flush_erat(void)
125 asm volatile(PPC_INVALIDATE_ERAT : : :"memory");
128 #define MCE_FLUSH_SLB 1
129 #define MCE_FLUSH_TLB 2
130 #define MCE_FLUSH_ERAT 3
132 static int mce_flush(int what)
134 #ifdef CONFIG_PPC_STD_MMU_64
135 if (what == MCE_FLUSH_SLB) {
136 flush_and_reload_slb();
140 if (what == MCE_FLUSH_ERAT) {
144 if (what == MCE_FLUSH_TLB) {
145 if (cur_cpu_spec && cur_cpu_spec->flush_tlb) {
146 cur_cpu_spec->flush_tlb(TLB_INVAL_SCOPE_GLOBAL);
154 #define SRR1_MC_LOADSTORE(srr1) ((srr1) & PPC_BIT(42))
156 struct mce_ierror_table {
157 unsigned long srr1_mask;
158 unsigned long srr1_value;
159 bool nip_valid; /* nip is a valid indicator of faulting address */
160 unsigned int error_type;
161 unsigned int error_subtype;
162 unsigned int initiator;
163 unsigned int severity;
166 static const struct mce_ierror_table mce_p7_ierror_table[] = {
167 { 0x00000000001c0000, 0x0000000000040000, true,
168 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_IFETCH,
169 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
170 { 0x00000000001c0000, 0x0000000000080000, true,
171 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
172 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
173 { 0x00000000001c0000, 0x00000000000c0000, true,
174 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
175 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
176 { 0x00000000001c0000, 0x0000000000100000, true,
177 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_INDETERMINATE, /* BOTH */
178 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
179 { 0x00000000001c0000, 0x0000000000140000, true,
180 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
181 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
182 { 0x00000000001c0000, 0x0000000000180000, true,
183 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_IFETCH,
184 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
185 { 0x00000000001c0000, 0x00000000001c0000, true,
186 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_IFETCH,
187 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
188 { 0, 0, 0, 0, 0, 0 } };
190 static const struct mce_ierror_table mce_p8_ierror_table[] = {
191 { 0x00000000081c0000, 0x0000000000040000, true,
192 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_IFETCH,
193 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
194 { 0x00000000081c0000, 0x0000000000080000, true,
195 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
196 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
197 { 0x00000000081c0000, 0x00000000000c0000, true,
198 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
199 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
200 { 0x00000000081c0000, 0x0000000000100000, true,
201 MCE_ERROR_TYPE_ERAT,MCE_ERAT_ERROR_MULTIHIT,
202 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
203 { 0x00000000081c0000, 0x0000000000140000, true,
204 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
205 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
206 { 0x00000000081c0000, 0x0000000000180000, true,
207 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_IFETCH,
208 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
209 { 0x00000000081c0000, 0x00000000001c0000, true,
210 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_IFETCH,
211 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
212 { 0x00000000081c0000, 0x0000000008000000, true,
213 MCE_ERROR_TYPE_LINK,MCE_LINK_ERROR_IFETCH_TIMEOUT,
214 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
215 { 0x00000000081c0000, 0x0000000008040000, true,
216 MCE_ERROR_TYPE_LINK,MCE_LINK_ERROR_PAGE_TABLE_WALK_IFETCH_TIMEOUT,
217 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
218 { 0, 0, 0, 0, 0, 0 } };
220 static const struct mce_ierror_table mce_p9_ierror_table[] = {
221 { 0x00000000081c0000, 0x0000000000040000, true,
222 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_IFETCH,
223 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
224 { 0x00000000081c0000, 0x0000000000080000, true,
225 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
226 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
227 { 0x00000000081c0000, 0x00000000000c0000, true,
228 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
229 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
230 { 0x00000000081c0000, 0x0000000000100000, true,
231 MCE_ERROR_TYPE_ERAT,MCE_ERAT_ERROR_MULTIHIT,
232 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
233 { 0x00000000081c0000, 0x0000000000140000, true,
234 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
235 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
236 { 0x00000000081c0000, 0x0000000000180000, true,
237 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_IFETCH,
238 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
239 { 0x00000000081c0000, 0x0000000008000000, true,
240 MCE_ERROR_TYPE_LINK,MCE_LINK_ERROR_IFETCH_TIMEOUT,
241 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
242 { 0x00000000081c0000, 0x0000000008040000, true,
243 MCE_ERROR_TYPE_LINK,MCE_LINK_ERROR_PAGE_TABLE_WALK_IFETCH_TIMEOUT,
244 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
245 { 0x00000000081c0000, 0x00000000080c0000, true,
246 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_IFETCH,
247 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
248 { 0x00000000081c0000, 0x0000000008100000, true,
249 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_PAGE_TABLE_WALK_IFETCH,
250 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
251 { 0x00000000081c0000, 0x0000000008140000, false,
252 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_STORE,
253 MCE_INITIATOR_CPU, MCE_SEV_FATAL, }, /* ASYNC is fatal */
254 { 0x00000000081c0000, 0x0000000008180000, false,
255 MCE_ERROR_TYPE_LINK,MCE_LINK_ERROR_STORE_TIMEOUT,
256 MCE_INITIATOR_CPU, MCE_SEV_FATAL, }, /* ASYNC is fatal */
257 { 0x00000000081c0000, 0x00000000081c0000, true,
258 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_PAGE_TABLE_WALK_IFETCH_FOREIGN,
259 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
260 { 0, 0, 0, 0, 0, 0 } };
262 struct mce_derror_table {
263 unsigned long dsisr_value;
264 bool dar_valid; /* dar is a valid indicator of faulting address */
265 unsigned int error_type;
266 unsigned int error_subtype;
267 unsigned int initiator;
268 unsigned int severity;
271 static const struct mce_derror_table mce_p7_derror_table[] = {
273 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_LOAD_STORE,
274 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
276 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_LOAD_STORE,
277 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
279 MCE_ERROR_TYPE_ERAT, MCE_ERAT_ERROR_MULTIHIT,
280 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
282 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
283 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
285 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
286 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
288 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
289 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
291 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_INDETERMINATE, /* BOTH */
292 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
293 { 0, false, 0, 0, 0, 0 } };
295 static const struct mce_derror_table mce_p8_derror_table[] = {
297 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_LOAD_STORE,
298 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
300 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_LOAD_STORE,
301 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
303 MCE_ERROR_TYPE_LINK, MCE_LINK_ERROR_LOAD_TIMEOUT,
304 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
306 MCE_ERROR_TYPE_LINK, MCE_LINK_ERROR_PAGE_TABLE_WALK_LOAD_STORE_TIMEOUT,
307 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
309 MCE_ERROR_TYPE_ERAT, MCE_ERAT_ERROR_MULTIHIT,
310 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
312 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
313 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
315 MCE_ERROR_TYPE_ERAT, MCE_ERAT_ERROR_MULTIHIT, /* SECONDARY ERAT */
316 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
318 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
319 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
321 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
322 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
323 { 0, false, 0, 0, 0, 0 } };
325 static const struct mce_derror_table mce_p9_derror_table[] = {
327 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_LOAD_STORE,
328 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
330 MCE_ERROR_TYPE_UE, MCE_UE_ERROR_PAGE_TABLE_WALK_LOAD_STORE,
331 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
333 MCE_ERROR_TYPE_LINK, MCE_LINK_ERROR_LOAD_TIMEOUT,
334 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
336 MCE_ERROR_TYPE_LINK, MCE_LINK_ERROR_PAGE_TABLE_WALK_LOAD_STORE_TIMEOUT,
337 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
339 MCE_ERROR_TYPE_ERAT, MCE_ERAT_ERROR_MULTIHIT,
340 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
342 MCE_ERROR_TYPE_TLB, MCE_TLB_ERROR_MULTIHIT,
343 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
345 MCE_ERROR_TYPE_USER, MCE_USER_ERROR_TLBIE,
346 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
348 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_PARITY,
349 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
351 MCE_ERROR_TYPE_SLB, MCE_SLB_ERROR_MULTIHIT,
352 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
354 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_LOAD,
355 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
357 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_PAGE_TABLE_WALK_LOAD_STORE,
358 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
360 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_PAGE_TABLE_WALK_LOAD_STORE_FOREIGN,
361 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
363 MCE_ERROR_TYPE_RA, MCE_RA_ERROR_LOAD_STORE_FOREIGN,
364 MCE_INITIATOR_CPU, MCE_SEV_ERROR_SYNC, },
365 { 0, false, 0, 0, 0, 0 } };
367 static int mce_handle_ierror(struct pt_regs *regs,
368 const struct mce_ierror_table table[],
369 struct mce_error_info *mce_err, uint64_t *addr)
371 uint64_t srr1 = regs->msr;
377 for (i = 0; table[i].srr1_mask; i++) {
378 if ((srr1 & table[i].srr1_mask) != table[i].srr1_value)
381 /* attempt to correct the error */
382 switch (table[i].error_type) {
383 case MCE_ERROR_TYPE_SLB:
384 handled = mce_flush(MCE_FLUSH_SLB);
386 case MCE_ERROR_TYPE_ERAT:
387 handled = mce_flush(MCE_FLUSH_ERAT);
389 case MCE_ERROR_TYPE_TLB:
390 handled = mce_flush(MCE_FLUSH_TLB);
394 /* now fill in mce_error_info */
395 mce_err->error_type = table[i].error_type;
396 switch (table[i].error_type) {
397 case MCE_ERROR_TYPE_UE:
398 mce_err->u.ue_error_type = table[i].error_subtype;
400 case MCE_ERROR_TYPE_SLB:
401 mce_err->u.slb_error_type = table[i].error_subtype;
403 case MCE_ERROR_TYPE_ERAT:
404 mce_err->u.erat_error_type = table[i].error_subtype;
406 case MCE_ERROR_TYPE_TLB:
407 mce_err->u.tlb_error_type = table[i].error_subtype;
409 case MCE_ERROR_TYPE_USER:
410 mce_err->u.user_error_type = table[i].error_subtype;
412 case MCE_ERROR_TYPE_RA:
413 mce_err->u.ra_error_type = table[i].error_subtype;
415 case MCE_ERROR_TYPE_LINK:
416 mce_err->u.link_error_type = table[i].error_subtype;
419 mce_err->severity = table[i].severity;
420 mce_err->initiator = table[i].initiator;
421 if (table[i].nip_valid)
426 mce_err->error_type = MCE_ERROR_TYPE_UNKNOWN;
427 mce_err->severity = MCE_SEV_ERROR_SYNC;
428 mce_err->initiator = MCE_INITIATOR_CPU;
433 static int mce_handle_derror(struct pt_regs *regs,
434 const struct mce_derror_table table[],
435 struct mce_error_info *mce_err, uint64_t *addr)
437 uint64_t dsisr = regs->dsisr;
444 for (i = 0; table[i].dsisr_value; i++) {
445 if (!(dsisr & table[i].dsisr_value))
448 /* attempt to correct the error */
449 switch (table[i].error_type) {
450 case MCE_ERROR_TYPE_SLB:
451 if (mce_flush(MCE_FLUSH_SLB))
454 case MCE_ERROR_TYPE_ERAT:
455 if (mce_flush(MCE_FLUSH_ERAT))
458 case MCE_ERROR_TYPE_TLB:
459 if (mce_flush(MCE_FLUSH_TLB))
465 * Attempt to handle multiple conditions, but only return
466 * one. Ensure uncorrectable errors are first in the table
472 /* now fill in mce_error_info */
473 mce_err->error_type = table[i].error_type;
474 switch (table[i].error_type) {
475 case MCE_ERROR_TYPE_UE:
476 mce_err->u.ue_error_type = table[i].error_subtype;
478 case MCE_ERROR_TYPE_SLB:
479 mce_err->u.slb_error_type = table[i].error_subtype;
481 case MCE_ERROR_TYPE_ERAT:
482 mce_err->u.erat_error_type = table[i].error_subtype;
484 case MCE_ERROR_TYPE_TLB:
485 mce_err->u.tlb_error_type = table[i].error_subtype;
487 case MCE_ERROR_TYPE_USER:
488 mce_err->u.user_error_type = table[i].error_subtype;
490 case MCE_ERROR_TYPE_RA:
491 mce_err->u.ra_error_type = table[i].error_subtype;
493 case MCE_ERROR_TYPE_LINK:
494 mce_err->u.link_error_type = table[i].error_subtype;
497 mce_err->severity = table[i].severity;
498 mce_err->initiator = table[i].initiator;
499 if (table[i].dar_valid)
508 mce_err->error_type = MCE_ERROR_TYPE_UNKNOWN;
509 mce_err->severity = MCE_SEV_ERROR_SYNC;
510 mce_err->initiator = MCE_INITIATOR_CPU;
515 static long mce_handle_ue_error(struct pt_regs *regs)
520 * On specific SCOM read via MMIO we may get a machine check
521 * exception with SRR0 pointing inside opal. If that is the
522 * case OPAL may have recovery address to re-read SCOM data in
523 * different way and hence we can recover from this MC.
526 if (ppc_md.mce_check_early_recovery) {
527 if (ppc_md.mce_check_early_recovery(regs))
533 static long mce_handle_error(struct pt_regs *regs,
534 const struct mce_derror_table dtable[],
535 const struct mce_ierror_table itable[])
537 struct mce_error_info mce_err = { 0 };
539 uint64_t srr1 = regs->msr;
542 if (SRR1_MC_LOADSTORE(srr1))
543 handled = mce_handle_derror(regs, dtable, &mce_err, &addr);
545 handled = mce_handle_ierror(regs, itable, &mce_err, &addr);
547 if (!handled && mce_err.error_type == MCE_ERROR_TYPE_UE)
548 handled = mce_handle_ue_error(regs);
550 save_mce_event(regs, handled, &mce_err, regs->nip, addr);
555 long __machine_check_early_realmode_p7(struct pt_regs *regs)
557 /* P7 DD1 leaves top bits of DSISR undefined */
558 regs->dsisr &= 0x0000ffff;
560 return mce_handle_error(regs, mce_p7_derror_table, mce_p7_ierror_table);
563 long __machine_check_early_realmode_p8(struct pt_regs *regs)
565 return mce_handle_error(regs, mce_p8_derror_table, mce_p8_ierror_table);
568 long __machine_check_early_realmode_p9(struct pt_regs *regs)
570 return mce_handle_error(regs, mce_p9_derror_table, mce_p9_ierror_table);