3 * Purpose: Generic MCA handling layer
5 * Copyright (C) 2004 FUJITSU LIMITED
6 * Copyright (C) Hidetoshi Seto (seto.hidetoshi@jp.fujitsu.com)
7 * Copyright (C) 2005 Silicon Graphics, Inc
8 * Copyright (C) 2005 Keith Owens <kaos@sgi.com>
9 * Copyright (C) 2006 Russ Anderson <rja@sgi.com>
11 #include <linux/config.h>
12 #include <linux/types.h>
13 #include <linux/init.h>
14 #include <linux/sched.h>
15 #include <linux/interrupt.h>
16 #include <linux/irq.h>
17 #include <linux/kallsyms.h>
18 #include <linux/smp_lock.h>
19 #include <linux/bootmem.h>
20 #include <linux/acpi.h>
21 #include <linux/timer.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/smp.h>
25 #include <linux/workqueue.h>
28 #include <asm/delay.h>
29 #include <asm/machvec.h>
31 #include <asm/ptrace.h>
32 #include <asm/system.h>
37 #include <asm/hw_irq.h>
41 /* max size of SAL error record (default) */
42 static int sal_rec_max
= 10000;
44 /* from mca_drv_asm.S */
45 extern void *mca_handler_bhhook(void);
47 static DEFINE_SPINLOCK(mca_bh_lock
);
54 #define MAX_PAGE_ISOLATE 1024
56 static struct page
*page_isolate
[MAX_PAGE_ISOLATE
];
57 static int num_page_isolate
= 0;
66 MCA_NOT_RECOVERED
= 0,
71 * This pool keeps pointers to the section part of SAL error record
74 slidx_list_t
*buffer
; /* section pointer list pool */
75 int cur_idx
; /* Current index of section pointer list pool */
76 int max_idx
; /* Maximum index of section pointer list pool */
80 fatal_mca(const char *fmt
, ...)
88 return MCA_NOT_RECOVERED
;
92 * mca_page_isolate - isolate a poisoned page in order not to use it later
93 * @paddr: poisoned memory location
96 * one of isolate_status_t, ISOLATE_OK/NG/NONE.
99 static isolate_status_t
100 mca_page_isolate(unsigned long paddr
)
105 /* whether physical address is valid or not */
106 if (!ia64_phys_addr_valid(paddr
))
109 if (!pfn_valid(paddr
>> PAGE_SHIFT
))
112 /* convert physical address to physical page number */
113 p
= pfn_to_page(paddr
>>PAGE_SHIFT
);
115 /* check whether a page number have been already registered or not */
116 for (i
= 0; i
< num_page_isolate
; i
++)
117 if (page_isolate
[i
] == p
)
118 return ISOLATE_OK
; /* already listed */
120 /* limitation check */
121 if (num_page_isolate
== MAX_PAGE_ISOLATE
)
124 /* kick pages having attribute 'SLAB' or 'Reserved' */
125 if (PageSlab(p
) || PageReserved(p
))
128 /* add attribute 'Reserved' and register the page */
131 page_isolate
[num_page_isolate
++] = p
;
137 * mca_hanlder_bh - Kill the process which occurred memory read error
138 * @paddr: poisoned address received from MCA Handler
142 mca_handler_bh(unsigned long paddr
, void *iip
, unsigned long ipsr
)
144 printk(KERN_ERR
"OS_MCA: process [cpu %d, pid: %d, uid: %d, "
145 "iip: %p, psr: 0x%lx,paddr: 0x%lx](%s) encounters MCA.\n",
146 raw_smp_processor_id(), current
->pid
, current
->uid
,
147 iip
, ipsr
, paddr
, current
->comm
);
149 spin_lock(&mca_bh_lock
);
150 switch (mca_page_isolate(paddr
)) {
152 printk(KERN_DEBUG
"Page isolation: ( %lx ) success.\n", paddr
);
155 printk(KERN_CRIT
"Page isolation: ( %lx ) failure.\n", paddr
);
160 spin_unlock(&mca_bh_lock
);
162 /* This process is about to be killed itself */
167 * mca_make_peidx - Make index of processor error section
168 * @slpi: pointer to record of processor error section
169 * @peidx: pointer to index of processor error section
173 mca_make_peidx(sal_log_processor_info_t
*slpi
, peidx_table_t
*peidx
)
176 * calculate the start address of
177 * "struct cpuid_info" and "sal_processor_static_info_t".
179 u64 total_check_num
= slpi
->valid
.num_cache_check
180 + slpi
->valid
.num_tlb_check
181 + slpi
->valid
.num_bus_check
182 + slpi
->valid
.num_reg_file_check
183 + slpi
->valid
.num_ms_check
;
184 u64 head_size
= sizeof(sal_log_mod_error_info_t
) * total_check_num
185 + sizeof(sal_log_processor_info_t
);
186 u64 mid_size
= slpi
->valid
.cpuid_info
* sizeof(struct sal_cpuid_info
);
188 peidx_head(peidx
) = slpi
;
189 peidx_mid(peidx
) = (struct sal_cpuid_info
*)
190 (slpi
->valid
.cpuid_info
? ((char*)slpi
+ head_size
) : NULL
);
191 peidx_bottom(peidx
) = (sal_processor_static_info_t
*)
192 (slpi
->valid
.psi_static_struct
?
193 ((char*)slpi
+ head_size
+ mid_size
) : NULL
);
197 * mca_make_slidx - Make index of SAL error record
198 * @buffer: pointer to SAL error record
199 * @slidx: pointer to index of SAL error record
202 * 1 if record has platform error / 0 if not
204 #define LOG_INDEX_ADD_SECT_PTR(sect, ptr) \
205 {slidx_list_t *hl = &slidx_pool.buffer[slidx_pool.cur_idx]; \
207 list_add(&hl->list, &(sect)); \
208 slidx_pool.cur_idx = (slidx_pool.cur_idx + 1)%slidx_pool.max_idx; }
211 mca_make_slidx(void *buffer
, slidx_table_t
*slidx
)
213 int platform_err
= 0;
214 int record_len
= ((sal_log_record_header_t
*)buffer
)->len
;
217 sal_log_section_hdr_t
*sp
;
220 * Initialize index referring current record
222 INIT_LIST_HEAD(&(slidx
->proc_err
));
223 INIT_LIST_HEAD(&(slidx
->mem_dev_err
));
224 INIT_LIST_HEAD(&(slidx
->sel_dev_err
));
225 INIT_LIST_HEAD(&(slidx
->pci_bus_err
));
226 INIT_LIST_HEAD(&(slidx
->smbios_dev_err
));
227 INIT_LIST_HEAD(&(slidx
->pci_comp_err
));
228 INIT_LIST_HEAD(&(slidx
->plat_specific_err
));
229 INIT_LIST_HEAD(&(slidx
->host_ctlr_err
));
230 INIT_LIST_HEAD(&(slidx
->plat_bus_err
));
231 INIT_LIST_HEAD(&(slidx
->unsupported
));
234 * Extract a Record Header
236 slidx
->header
= buffer
;
239 * Extract each section records
240 * (arranged from "int ia64_log_platform_info_print()")
242 for (ercd_pos
= sizeof(sal_log_record_header_t
), sects
= 0;
243 ercd_pos
< record_len
; ercd_pos
+= sp
->len
, sects
++) {
244 sp
= (sal_log_section_hdr_t
*)((char*)buffer
+ ercd_pos
);
245 if (!efi_guidcmp(sp
->guid
, SAL_PROC_DEV_ERR_SECT_GUID
)) {
246 LOG_INDEX_ADD_SECT_PTR(slidx
->proc_err
, sp
);
247 } else if (!efi_guidcmp(sp
->guid
,
248 SAL_PLAT_MEM_DEV_ERR_SECT_GUID
)) {
250 LOG_INDEX_ADD_SECT_PTR(slidx
->mem_dev_err
, sp
);
251 } else if (!efi_guidcmp(sp
->guid
,
252 SAL_PLAT_SEL_DEV_ERR_SECT_GUID
)) {
254 LOG_INDEX_ADD_SECT_PTR(slidx
->sel_dev_err
, sp
);
255 } else if (!efi_guidcmp(sp
->guid
,
256 SAL_PLAT_PCI_BUS_ERR_SECT_GUID
)) {
258 LOG_INDEX_ADD_SECT_PTR(slidx
->pci_bus_err
, sp
);
259 } else if (!efi_guidcmp(sp
->guid
,
260 SAL_PLAT_SMBIOS_DEV_ERR_SECT_GUID
)) {
262 LOG_INDEX_ADD_SECT_PTR(slidx
->smbios_dev_err
, sp
);
263 } else if (!efi_guidcmp(sp
->guid
,
264 SAL_PLAT_PCI_COMP_ERR_SECT_GUID
)) {
266 LOG_INDEX_ADD_SECT_PTR(slidx
->pci_comp_err
, sp
);
267 } else if (!efi_guidcmp(sp
->guid
,
268 SAL_PLAT_SPECIFIC_ERR_SECT_GUID
)) {
270 LOG_INDEX_ADD_SECT_PTR(slidx
->plat_specific_err
, sp
);
271 } else if (!efi_guidcmp(sp
->guid
,
272 SAL_PLAT_HOST_CTLR_ERR_SECT_GUID
)) {
274 LOG_INDEX_ADD_SECT_PTR(slidx
->host_ctlr_err
, sp
);
275 } else if (!efi_guidcmp(sp
->guid
,
276 SAL_PLAT_BUS_ERR_SECT_GUID
)) {
278 LOG_INDEX_ADD_SECT_PTR(slidx
->plat_bus_err
, sp
);
280 LOG_INDEX_ADD_SECT_PTR(slidx
->unsupported
, sp
);
283 slidx
->n_sections
= sects
;
289 * init_record_index_pools - Initialize pool of lists for SAL record index
292 * 0 on Success / -ENOMEM on Failure
295 init_record_index_pools(void)
298 int rec_max_size
; /* Maximum size of SAL error records */
299 int sect_min_size
; /* Minimum size of SAL error sections */
300 /* minimum size table of each section */
301 static int sal_log_sect_min_sizes
[] = {
302 sizeof(sal_log_processor_info_t
)
303 + sizeof(sal_processor_static_info_t
),
304 sizeof(sal_log_mem_dev_err_info_t
),
305 sizeof(sal_log_sel_dev_err_info_t
),
306 sizeof(sal_log_pci_bus_err_info_t
),
307 sizeof(sal_log_smbios_dev_err_info_t
),
308 sizeof(sal_log_pci_comp_err_info_t
),
309 sizeof(sal_log_plat_specific_err_info_t
),
310 sizeof(sal_log_host_ctlr_err_info_t
),
311 sizeof(sal_log_plat_bus_err_info_t
),
315 * MCA handler cannot allocate new memory on flight,
316 * so we preallocate enough memory to handle a SAL record.
318 * Initialize a handling set of slidx_pool:
319 * 1. Pick up the max size of SAL error records
320 * 2. Pick up the min size of SAL error sections
321 * 3. Allocate the pool as enough to 2 SAL records
322 * (now we can estimate the maxinum of section in a record.)
326 rec_max_size
= sal_rec_max
;
329 sect_min_size
= sal_log_sect_min_sizes
[0];
330 for (i
= 1; i
< sizeof sal_log_sect_min_sizes
/sizeof(size_t); i
++)
331 if (sect_min_size
> sal_log_sect_min_sizes
[i
])
332 sect_min_size
= sal_log_sect_min_sizes
[i
];
335 slidx_pool
.max_idx
= (rec_max_size
/sect_min_size
) * 2 + 1;
336 slidx_pool
.buffer
= (slidx_list_t
*)
337 kmalloc(slidx_pool
.max_idx
* sizeof(slidx_list_t
), GFP_KERNEL
);
339 return slidx_pool
.buffer
? 0 : -ENOMEM
;
343 /*****************************************************************************
344 * Recovery functions *
345 *****************************************************************************/
348 * is_mca_global - Check whether this MCA is global or not
349 * @peidx: pointer of index of processor error section
350 * @pbci: pointer to pal_bus_check_info_t
351 * @sos: pointer to hand off struct between SAL and OS
354 * MCA_IS_LOCAL / MCA_IS_GLOBAL
358 is_mca_global(peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
359 struct ia64_sal_os_state
*sos
)
361 pal_processor_state_info_t
*psp
=
362 (pal_processor_state_info_t
*)peidx_psp(peidx
);
365 * PAL can request a rendezvous, if the MCA has a global scope.
366 * If "rz_always" flag is set, SAL requests MCA rendezvous
367 * in spite of global MCA.
368 * Therefore it is local MCA when rendezvous has not been requested.
369 * Failed to rendezvous, the system must be down.
371 switch (sos
->rv_rc
) {
372 case -1: /* SAL rendezvous unsuccessful */
373 return MCA_IS_GLOBAL
;
374 case 0: /* SAL rendezvous not required */
376 case 1: /* SAL rendezvous successful int */
377 case 2: /* SAL rendezvous successful int with init */
383 * If One or more Cache/TLB/Reg_File/Uarch_Check is here,
384 * it would be a local MCA. (i.e. processor internal error)
386 if (psp
->tc
|| psp
->cc
|| psp
->rc
|| psp
->uc
)
390 * Bus_Check structure with Bus_Check.ib (internal bus error) flag set
391 * would be a global MCA. (e.g. a system bus address parity error)
393 if (!pbci
|| pbci
->ib
)
394 return MCA_IS_GLOBAL
;
397 * Bus_Check structure with Bus_Check.eb (external bus error) flag set
398 * could be either a local MCA or a global MCA.
400 * Referring Bus_Check.bsi:
401 * 0: Unknown/unclassified
405 * (FIXME: Are these SGI specific or generic bsi values?)
410 /* e.g. a load from poisoned memory */
415 return MCA_IS_GLOBAL
;
418 return MCA_IS_GLOBAL
;
422 * recover_from_read_error - Try to recover the errors which type are "read"s.
423 * @slidx: pointer of index of SAL error record
424 * @peidx: pointer of index of processor error section
425 * @pbci: pointer of pal_bus_check_info
426 * @sos: pointer to hand off struct between SAL and OS
429 * 1 on Success / 0 on Failure
433 recover_from_read_error(slidx_table_t
*slidx
,
434 peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
435 struct ia64_sal_os_state
*sos
)
437 sal_log_mod_error_info_t
*smei
;
438 pal_min_state_area_t
*pmsa
;
439 struct ia64_psr
*psr1
, *psr2
;
440 ia64_fptr_t
*mca_hdlr_bh
= (ia64_fptr_t
*)mca_handler_bhhook
;
442 /* Is target address valid? */
444 return fatal_mca(KERN_ALERT
"MCA: target address not valid\n");
447 * cpu read or memory-mapped io read
449 * offending process affected process OS MCA do
450 * kernel mode kernel mode down system
451 * kernel mode user mode kill the process
452 * user mode kernel mode down system (*)
453 * user mode user mode kill the process
455 * (*) You could terminate offending user-mode process
456 * if (pbci->pv && pbci->pl != 0) *and* if you sure
457 * the process not have any locks of kernel.
460 /* Is minstate valid? */
461 if (!peidx_bottom(peidx
) || !(peidx_bottom(peidx
)->valid
.minstate
))
462 return fatal_mca(KERN_ALERT
"MCA: minstate not valid\n");
463 psr1
=(struct ia64_psr
*)&(peidx_minstate_area(peidx
)->pmsa_ipsr
);
464 psr2
=(struct ia64_psr
*)&(peidx_minstate_area(peidx
)->pmsa_xpsr
);
467 * Check the privilege level of interrupted context.
468 * If it is user-mode, then terminate affected process.
471 pmsa
= sos
->pal_min_state
;
472 if (psr1
->cpl
!= 0 ||
473 ((psr2
->cpl
!= 0) && mca_recover_range(pmsa
->pmsa_iip
))) {
474 smei
= peidx_bus_check(peidx
, 0);
475 if (smei
->valid
.target_identifier
) {
477 * setup for resume to bottom half of MCA,
478 * "mca_handler_bhhook"
480 /* pass to bhhook as argument (gr8, ...) */
481 pmsa
->pmsa_gr
[8-1] = smei
->target_identifier
;
482 pmsa
->pmsa_gr
[9-1] = pmsa
->pmsa_iip
;
483 pmsa
->pmsa_gr
[10-1] = pmsa
->pmsa_ipsr
;
484 /* set interrupted return address (but no use) */
485 pmsa
->pmsa_br0
= pmsa
->pmsa_iip
;
486 /* change resume address to bottom half */
487 pmsa
->pmsa_iip
= mca_hdlr_bh
->fp
;
488 pmsa
->pmsa_gr
[1-1] = mca_hdlr_bh
->gp
;
489 /* set cpl with kernel mode */
490 psr2
= (struct ia64_psr
*)&pmsa
->pmsa_ipsr
;
496 return MCA_RECOVERED
;
501 return fatal_mca(KERN_ALERT
"MCA: kernel context not recovered,"
502 " iip 0x%lx\n", pmsa
->pmsa_iip
);
506 * recover_from_platform_error - Recover from platform error.
507 * @slidx: pointer of index of SAL error record
508 * @peidx: pointer of index of processor error section
509 * @pbci: pointer of pal_bus_check_info
510 * @sos: pointer to hand off struct between SAL and OS
513 * 1 on Success / 0 on Failure
517 recover_from_platform_error(slidx_table_t
*slidx
, peidx_table_t
*peidx
,
518 pal_bus_check_info_t
*pbci
,
519 struct ia64_sal_os_state
*sos
)
522 pal_processor_state_info_t
*psp
=
523 (pal_processor_state_info_t
*)peidx_psp(peidx
);
525 if (psp
->bc
&& pbci
->eb
&& pbci
->bsi
== 0) {
527 case 1: /* partial read */
528 case 3: /* full line(cpu) read */
529 case 9: /* I/O space read */
530 status
= recover_from_read_error(slidx
, peidx
, pbci
,
533 case 0: /* unknown */
534 case 2: /* partial write */
535 case 4: /* full line write */
536 case 5: /* implicit or explicit write-back operation */
537 case 6: /* snoop probe */
538 case 7: /* incoming or outgoing ptc.g */
539 case 8: /* write coalescing transactions */
540 case 10: /* I/O space write */
541 case 11: /* inter-processor interrupt message(IPI) */
542 case 12: /* interrupt acknowledge or
543 external task priority cycle */
553 * recover_from_processor_error
554 * @platform: whether there are some platform error section or not
555 * @slidx: pointer of index of SAL error record
556 * @peidx: pointer of index of processor error section
557 * @pbci: pointer of pal_bus_check_info
558 * @sos: pointer to hand off struct between SAL and OS
561 * 1 on Success / 0 on Failure
564 * Later we try to recover when below all conditions are satisfied.
565 * 1. Only one processor error section is exist.
566 * 2. BUS_CHECK is exist and the others are not exist.(Except TLB_CHECK)
567 * 3. The entry of BUS_CHECK_INFO is 1.
568 * 4. "External bus error" flag is set and the others are not set.
572 recover_from_processor_error(int platform
, slidx_table_t
*slidx
,
573 peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
574 struct ia64_sal_os_state
*sos
)
576 pal_processor_state_info_t
*psp
=
577 (pal_processor_state_info_t
*)peidx_psp(peidx
);
580 * Processor recovery status must key off of the PAL recovery
581 * status in the Processor State Parameter.
585 * The machine check is corrected.
588 return MCA_RECOVERED
;
591 * The error was not contained. Software must be reset.
593 if (psp
->us
|| psp
->ci
== 0)
594 return fatal_mca(KERN_ALERT
"MCA: error not contained\n");
597 * The cache check and bus check bits have four possible states
599 * 0 0 Weird record, not recovered
600 * 1 0 Cache error, not recovered
601 * 0 1 I/O error, attempt recovery
602 * 1 1 Memory error, attempt recovery
604 if (psp
->bc
== 0 || pbci
== NULL
)
605 return fatal_mca(KERN_ALERT
"MCA: No bus check\n");
608 * Sorry, we cannot handle so many.
610 if (peidx_bus_check_num(peidx
) > 1)
611 return fatal_mca(KERN_ALERT
"MCA: Too many bus checks\n");
613 * Well, here is only one bus error.
616 return fatal_mca(KERN_ALERT
"MCA: Internal Bus error\n");
618 return fatal_mca(KERN_ALERT
"MCA: Cache-cache error\n");
619 if (pbci
->eb
&& pbci
->bsi
> 0)
620 return fatal_mca(KERN_ALERT
"MCA: External bus check fatal status\n");
623 * This is a local MCA and estimated as recoverble external bus error.
624 * (e.g. a load from poisoned memory)
625 * This means "there are some platform errors".
628 return recover_from_platform_error(slidx
, peidx
, pbci
, sos
);
630 * On account of strange SAL error record, we cannot recover.
632 return fatal_mca(KERN_ALERT
"MCA: Strange SAL record\n");
636 * mca_try_to_recover - Try to recover from MCA
637 * @rec: pointer to a SAL error record
638 * @sos: pointer to hand off struct between SAL and OS
641 * 1 on Success / 0 on Failure
645 mca_try_to_recover(void *rec
, struct ia64_sal_os_state
*sos
)
651 pal_bus_check_info_t pbci
;
653 /* Make index of SAL error record */
654 platform_err
= mca_make_slidx(rec
, &slidx
);
656 /* Count processor error sections */
657 n_proc_err
= slidx_count(&slidx
, proc_err
);
659 /* Now, OS can recover when there is one processor error section */
661 return fatal_mca(KERN_ALERT
"MCA: Too Many Errors\n");
662 else if (n_proc_err
== 0)
663 /* Weird SAL record ... We need not to recover */
664 return fatal_mca(KERN_ALERT
"MCA: Weird SAL record\n");
666 /* Make index of processor error section */
667 mca_make_peidx((sal_log_processor_info_t
*)
668 slidx_first_entry(&slidx
.proc_err
)->hdr
, &peidx
);
670 /* Extract Processor BUS_CHECK[0] */
671 *((u64
*)&pbci
) = peidx_check_info(&peidx
, bus_check
, 0);
673 /* Check whether MCA is global or not */
674 if (is_mca_global(&peidx
, &pbci
, sos
))
675 return fatal_mca(KERN_ALERT
"MCA: global MCA\n");
677 /* Try to recover a processor error */
678 return recover_from_processor_error(platform_err
, &slidx
, &peidx
,
683 * =============================================================================
686 int __init
mca_external_handler_init(void)
688 if (init_record_index_pools())
691 /* register external mca handlers */
692 if (ia64_reg_MCA_extension(mca_try_to_recover
)) {
693 printk(KERN_ERR
"ia64_reg_MCA_extension failed.\n");
694 kfree(slidx_pool
.buffer
);
700 void __exit
mca_external_handler_exit(void)
702 /* unregister external mca handlers */
703 ia64_unreg_MCA_extension();
704 kfree(slidx_pool
.buffer
);
707 module_init(mca_external_handler_init
);
708 module_exit(mca_external_handler_exit
);
710 module_param(sal_rec_max
, int, 0644);
711 MODULE_PARM_DESC(sal_rec_max
, "Max size of SAL error record");
713 MODULE_DESCRIPTION("ia64 platform dependent mca handler driver");
714 MODULE_LICENSE("GPL");