3 * Purpose: Generic MCA handling layer
5 * Copyright (C) 2004 FUJITSU LIMITED
6 * Copyright (C) 2004 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/types.h>
12 #include <linux/init.h>
13 #include <linux/sched.h>
14 #include <linux/interrupt.h>
15 #include <linux/irq.h>
16 #include <linux/kallsyms.h>
17 #include <linux/bootmem.h>
18 #include <linux/acpi.h>
19 #include <linux/timer.h>
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/smp.h>
23 #include <linux/workqueue.h>
25 #include <linux/slab.h>
27 #include <asm/delay.h>
28 #include <asm/machvec.h>
30 #include <asm/ptrace.h>
31 #include <asm/system.h>
36 #include <asm/hw_irq.h>
40 /* max size of SAL error record (default) */
41 static int sal_rec_max
= 10000;
43 /* from mca_drv_asm.S */
44 extern void *mca_handler_bhhook(void);
46 static DEFINE_SPINLOCK(mca_bh_lock
);
53 #define MAX_PAGE_ISOLATE 1024
55 static struct page
*page_isolate
[MAX_PAGE_ISOLATE
];
56 static int num_page_isolate
= 0;
65 MCA_NOT_RECOVERED
= 0,
70 * This pool keeps pointers to the section part of SAL error record
73 slidx_list_t
*buffer
; /* section pointer list pool */
74 int cur_idx
; /* Current index of section pointer list pool */
75 int max_idx
; /* Maximum index of section pointer list pool */
79 fatal_mca(const char *fmt
, ...)
85 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
87 ia64_mca_printk(KERN_ALERT
"MCA: %s\n", buf
);
89 return MCA_NOT_RECOVERED
;
93 mca_recovered(const char *fmt
, ...)
99 vsnprintf(buf
, sizeof(buf
), fmt
, args
);
101 ia64_mca_printk(KERN_INFO
"MCA: %s\n", buf
);
103 return MCA_RECOVERED
;
107 * mca_page_isolate - isolate a poisoned page in order not to use it later
108 * @paddr: poisoned memory location
111 * one of isolate_status_t, ISOLATE_OK/NG/NONE.
114 static isolate_status_t
115 mca_page_isolate(unsigned long paddr
)
120 /* whether physical address is valid or not */
121 if (!ia64_phys_addr_valid(paddr
))
124 if (!pfn_valid(paddr
>> PAGE_SHIFT
))
127 /* convert physical address to physical page number */
128 p
= pfn_to_page(paddr
>>PAGE_SHIFT
);
130 /* check whether a page number have been already registered or not */
131 for (i
= 0; i
< num_page_isolate
; i
++)
132 if (page_isolate
[i
] == p
)
133 return ISOLATE_OK
; /* already listed */
135 /* limitation check */
136 if (num_page_isolate
== MAX_PAGE_ISOLATE
)
139 /* kick pages having attribute 'SLAB' or 'Reserved' */
140 if (PageSlab(p
) || PageReserved(p
))
143 /* add attribute 'Reserved' and register the page */
146 page_isolate
[num_page_isolate
++] = p
;
152 * mca_hanlder_bh - Kill the process which occurred memory read error
153 * @paddr: poisoned address received from MCA Handler
157 mca_handler_bh(unsigned long paddr
, void *iip
, unsigned long ipsr
)
160 printk(KERN_ERR
"OS_MCA: process [cpu %d, pid: %d, uid: %d, "
161 "iip: %p, psr: 0x%lx,paddr: 0x%lx](%s) encounters MCA.\n",
162 raw_smp_processor_id(), current
->pid
, current_uid(),
163 iip
, ipsr
, paddr
, current
->comm
);
165 spin_lock(&mca_bh_lock
);
166 switch (mca_page_isolate(paddr
)) {
168 printk(KERN_DEBUG
"Page isolation: ( %lx ) success.\n", paddr
);
171 printk(KERN_CRIT
"Page isolation: ( %lx ) failure.\n", paddr
);
176 spin_unlock(&mca_bh_lock
);
178 /* This process is about to be killed itself */
183 * mca_make_peidx - Make index of processor error section
184 * @slpi: pointer to record of processor error section
185 * @peidx: pointer to index of processor error section
189 mca_make_peidx(sal_log_processor_info_t
*slpi
, peidx_table_t
*peidx
)
192 * calculate the start address of
193 * "struct cpuid_info" and "sal_processor_static_info_t".
195 u64 total_check_num
= slpi
->valid
.num_cache_check
196 + slpi
->valid
.num_tlb_check
197 + slpi
->valid
.num_bus_check
198 + slpi
->valid
.num_reg_file_check
199 + slpi
->valid
.num_ms_check
;
200 u64 head_size
= sizeof(sal_log_mod_error_info_t
) * total_check_num
201 + sizeof(sal_log_processor_info_t
);
202 u64 mid_size
= slpi
->valid
.cpuid_info
* sizeof(struct sal_cpuid_info
);
204 peidx_head(peidx
) = slpi
;
205 peidx_mid(peidx
) = (struct sal_cpuid_info
*)
206 (slpi
->valid
.cpuid_info
? ((char*)slpi
+ head_size
) : NULL
);
207 peidx_bottom(peidx
) = (sal_processor_static_info_t
*)
208 (slpi
->valid
.psi_static_struct
?
209 ((char*)slpi
+ head_size
+ mid_size
) : NULL
);
213 * mca_make_slidx - Make index of SAL error record
214 * @buffer: pointer to SAL error record
215 * @slidx: pointer to index of SAL error record
218 * 1 if record has platform error / 0 if not
220 #define LOG_INDEX_ADD_SECT_PTR(sect, ptr) \
221 {slidx_list_t *hl = &slidx_pool.buffer[slidx_pool.cur_idx]; \
223 list_add(&hl->list, &(sect)); \
224 slidx_pool.cur_idx = (slidx_pool.cur_idx + 1)%slidx_pool.max_idx; }
227 mca_make_slidx(void *buffer
, slidx_table_t
*slidx
)
229 int platform_err
= 0;
230 int record_len
= ((sal_log_record_header_t
*)buffer
)->len
;
233 sal_log_section_hdr_t
*sp
;
236 * Initialize index referring current record
238 INIT_LIST_HEAD(&(slidx
->proc_err
));
239 INIT_LIST_HEAD(&(slidx
->mem_dev_err
));
240 INIT_LIST_HEAD(&(slidx
->sel_dev_err
));
241 INIT_LIST_HEAD(&(slidx
->pci_bus_err
));
242 INIT_LIST_HEAD(&(slidx
->smbios_dev_err
));
243 INIT_LIST_HEAD(&(slidx
->pci_comp_err
));
244 INIT_LIST_HEAD(&(slidx
->plat_specific_err
));
245 INIT_LIST_HEAD(&(slidx
->host_ctlr_err
));
246 INIT_LIST_HEAD(&(slidx
->plat_bus_err
));
247 INIT_LIST_HEAD(&(slidx
->unsupported
));
250 * Extract a Record Header
252 slidx
->header
= buffer
;
255 * Extract each section records
256 * (arranged from "int ia64_log_platform_info_print()")
258 for (ercd_pos
= sizeof(sal_log_record_header_t
), sects
= 0;
259 ercd_pos
< record_len
; ercd_pos
+= sp
->len
, sects
++) {
260 sp
= (sal_log_section_hdr_t
*)((char*)buffer
+ ercd_pos
);
261 if (!efi_guidcmp(sp
->guid
, SAL_PROC_DEV_ERR_SECT_GUID
)) {
262 LOG_INDEX_ADD_SECT_PTR(slidx
->proc_err
, sp
);
263 } else if (!efi_guidcmp(sp
->guid
,
264 SAL_PLAT_MEM_DEV_ERR_SECT_GUID
)) {
266 LOG_INDEX_ADD_SECT_PTR(slidx
->mem_dev_err
, sp
);
267 } else if (!efi_guidcmp(sp
->guid
,
268 SAL_PLAT_SEL_DEV_ERR_SECT_GUID
)) {
270 LOG_INDEX_ADD_SECT_PTR(slidx
->sel_dev_err
, sp
);
271 } else if (!efi_guidcmp(sp
->guid
,
272 SAL_PLAT_PCI_BUS_ERR_SECT_GUID
)) {
274 LOG_INDEX_ADD_SECT_PTR(slidx
->pci_bus_err
, sp
);
275 } else if (!efi_guidcmp(sp
->guid
,
276 SAL_PLAT_SMBIOS_DEV_ERR_SECT_GUID
)) {
278 LOG_INDEX_ADD_SECT_PTR(slidx
->smbios_dev_err
, sp
);
279 } else if (!efi_guidcmp(sp
->guid
,
280 SAL_PLAT_PCI_COMP_ERR_SECT_GUID
)) {
282 LOG_INDEX_ADD_SECT_PTR(slidx
->pci_comp_err
, sp
);
283 } else if (!efi_guidcmp(sp
->guid
,
284 SAL_PLAT_SPECIFIC_ERR_SECT_GUID
)) {
286 LOG_INDEX_ADD_SECT_PTR(slidx
->plat_specific_err
, sp
);
287 } else if (!efi_guidcmp(sp
->guid
,
288 SAL_PLAT_HOST_CTLR_ERR_SECT_GUID
)) {
290 LOG_INDEX_ADD_SECT_PTR(slidx
->host_ctlr_err
, sp
);
291 } else if (!efi_guidcmp(sp
->guid
,
292 SAL_PLAT_BUS_ERR_SECT_GUID
)) {
294 LOG_INDEX_ADD_SECT_PTR(slidx
->plat_bus_err
, sp
);
296 LOG_INDEX_ADD_SECT_PTR(slidx
->unsupported
, sp
);
299 slidx
->n_sections
= sects
;
305 * init_record_index_pools - Initialize pool of lists for SAL record index
308 * 0 on Success / -ENOMEM on Failure
311 init_record_index_pools(void)
314 int rec_max_size
; /* Maximum size of SAL error records */
315 int sect_min_size
; /* Minimum size of SAL error sections */
316 /* minimum size table of each section */
317 static int sal_log_sect_min_sizes
[] = {
318 sizeof(sal_log_processor_info_t
)
319 + sizeof(sal_processor_static_info_t
),
320 sizeof(sal_log_mem_dev_err_info_t
),
321 sizeof(sal_log_sel_dev_err_info_t
),
322 sizeof(sal_log_pci_bus_err_info_t
),
323 sizeof(sal_log_smbios_dev_err_info_t
),
324 sizeof(sal_log_pci_comp_err_info_t
),
325 sizeof(sal_log_plat_specific_err_info_t
),
326 sizeof(sal_log_host_ctlr_err_info_t
),
327 sizeof(sal_log_plat_bus_err_info_t
),
331 * MCA handler cannot allocate new memory on flight,
332 * so we preallocate enough memory to handle a SAL record.
334 * Initialize a handling set of slidx_pool:
335 * 1. Pick up the max size of SAL error records
336 * 2. Pick up the min size of SAL error sections
337 * 3. Allocate the pool as enough to 2 SAL records
338 * (now we can estimate the maxinum of section in a record.)
342 rec_max_size
= sal_rec_max
;
345 sect_min_size
= sal_log_sect_min_sizes
[0];
346 for (i
= 1; i
< sizeof sal_log_sect_min_sizes
/sizeof(size_t); i
++)
347 if (sect_min_size
> sal_log_sect_min_sizes
[i
])
348 sect_min_size
= sal_log_sect_min_sizes
[i
];
351 slidx_pool
.max_idx
= (rec_max_size
/sect_min_size
) * 2 + 1;
352 slidx_pool
.buffer
= (slidx_list_t
*)
353 kmalloc(slidx_pool
.max_idx
* sizeof(slidx_list_t
), GFP_KERNEL
);
355 return slidx_pool
.buffer
? 0 : -ENOMEM
;
359 /*****************************************************************************
360 * Recovery functions *
361 *****************************************************************************/
364 * is_mca_global - Check whether this MCA is global or not
365 * @peidx: pointer of index of processor error section
366 * @pbci: pointer to pal_bus_check_info_t
367 * @sos: pointer to hand off struct between SAL and OS
370 * MCA_IS_LOCAL / MCA_IS_GLOBAL
374 is_mca_global(peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
375 struct ia64_sal_os_state
*sos
)
377 pal_processor_state_info_t
*psp
=
378 (pal_processor_state_info_t
*)peidx_psp(peidx
);
381 * PAL can request a rendezvous, if the MCA has a global scope.
382 * If "rz_always" flag is set, SAL requests MCA rendezvous
383 * in spite of global MCA.
384 * Therefore it is local MCA when rendezvous has not been requested.
385 * Failed to rendezvous, the system must be down.
387 switch (sos
->rv_rc
) {
388 case -1: /* SAL rendezvous unsuccessful */
389 return MCA_IS_GLOBAL
;
390 case 0: /* SAL rendezvous not required */
392 case 1: /* SAL rendezvous successful int */
393 case 2: /* SAL rendezvous successful int with init */
399 * If One or more Cache/TLB/Reg_File/Uarch_Check is here,
400 * it would be a local MCA. (i.e. processor internal error)
402 if (psp
->tc
|| psp
->cc
|| psp
->rc
|| psp
->uc
)
406 * Bus_Check structure with Bus_Check.ib (internal bus error) flag set
407 * would be a global MCA. (e.g. a system bus address parity error)
409 if (!pbci
|| pbci
->ib
)
410 return MCA_IS_GLOBAL
;
415 /* e.g. a load from poisoned memory */
420 return MCA_IS_GLOBAL
;
423 return MCA_IS_GLOBAL
;
427 * get_target_identifier - Get the valid Cache or Bus check target identifier.
428 * @peidx: pointer of index of processor error section
431 * target address on Success / 0 on Failure
434 get_target_identifier(peidx_table_t
*peidx
)
436 u64 target_address
= 0;
437 sal_log_mod_error_info_t
*smei
;
438 pal_cache_check_info_t
*pcci
;
442 * Look through the cache checks for a valid target identifier
443 * If more than one valid target identifier, return the one
444 * with the lowest cache level.
446 for (i
= 0; i
< peidx_cache_check_num(peidx
); i
++) {
447 smei
= (sal_log_mod_error_info_t
*)peidx_cache_check(peidx
, i
);
448 if (smei
->valid
.target_identifier
&& smei
->target_identifier
) {
449 pcci
= (pal_cache_check_info_t
*)&(smei
->check_info
);
450 if (!target_address
|| (pcci
->level
< level
)) {
451 target_address
= smei
->target_identifier
;
458 return target_address
;
461 * Look at the bus check for a valid target identifier
463 smei
= peidx_bus_check(peidx
, 0);
464 if (smei
&& smei
->valid
.target_identifier
)
465 return smei
->target_identifier
;
471 * recover_from_read_error - Try to recover the errors which type are "read"s.
472 * @slidx: pointer of index of SAL error record
473 * @peidx: pointer of index of processor error section
474 * @pbci: pointer of pal_bus_check_info
475 * @sos: pointer to hand off struct between SAL and OS
478 * 1 on Success / 0 on Failure
482 recover_from_read_error(slidx_table_t
*slidx
,
483 peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
484 struct ia64_sal_os_state
*sos
)
486 u64 target_identifier
;
487 pal_min_state_area_t
*pmsa
;
488 struct ia64_psr
*psr1
, *psr2
;
489 ia64_fptr_t
*mca_hdlr_bh
= (ia64_fptr_t
*)mca_handler_bhhook
;
491 /* Is target address valid? */
492 target_identifier
= get_target_identifier(peidx
);
493 if (!target_identifier
)
494 return fatal_mca("target address not valid");
497 * cpu read or memory-mapped io read
499 * offending process affected process OS MCA do
500 * kernel mode kernel mode down system
501 * kernel mode user mode kill the process
502 * user mode kernel mode down system (*)
503 * user mode user mode kill the process
505 * (*) You could terminate offending user-mode process
506 * if (pbci->pv && pbci->pl != 0) *and* if you sure
507 * the process not have any locks of kernel.
510 /* Is minstate valid? */
511 if (!peidx_bottom(peidx
) || !(peidx_bottom(peidx
)->valid
.minstate
))
512 return fatal_mca("minstate not valid");
513 psr1
=(struct ia64_psr
*)&(peidx_minstate_area(peidx
)->pmsa_ipsr
);
514 psr2
=(struct ia64_psr
*)&(peidx_minstate_area(peidx
)->pmsa_xpsr
);
517 * Check the privilege level of interrupted context.
518 * If it is user-mode, then terminate affected process.
521 pmsa
= sos
->pal_min_state
;
522 if (psr1
->cpl
!= 0 ||
523 ((psr2
->cpl
!= 0) && mca_recover_range(pmsa
->pmsa_iip
))) {
525 * setup for resume to bottom half of MCA,
526 * "mca_handler_bhhook"
528 /* pass to bhhook as argument (gr8, ...) */
529 pmsa
->pmsa_gr
[8-1] = target_identifier
;
530 pmsa
->pmsa_gr
[9-1] = pmsa
->pmsa_iip
;
531 pmsa
->pmsa_gr
[10-1] = pmsa
->pmsa_ipsr
;
532 /* set interrupted return address (but no use) */
533 pmsa
->pmsa_br0
= pmsa
->pmsa_iip
;
534 /* change resume address to bottom half */
535 pmsa
->pmsa_iip
= mca_hdlr_bh
->fp
;
536 pmsa
->pmsa_gr
[1-1] = mca_hdlr_bh
->gp
;
537 /* set cpl with kernel mode */
538 psr2
= (struct ia64_psr
*)&pmsa
->pmsa_ipsr
;
544 return mca_recovered("user memory corruption. "
545 "kill affected process - recovered.");
548 return fatal_mca("kernel context not recovered, iip 0x%lx\n",
553 * recover_from_platform_error - Recover from platform error.
554 * @slidx: pointer of index of SAL error record
555 * @peidx: pointer of index of processor error section
556 * @pbci: pointer of pal_bus_check_info
557 * @sos: pointer to hand off struct between SAL and OS
560 * 1 on Success / 0 on Failure
564 recover_from_platform_error(slidx_table_t
*slidx
, peidx_table_t
*peidx
,
565 pal_bus_check_info_t
*pbci
,
566 struct ia64_sal_os_state
*sos
)
569 pal_processor_state_info_t
*psp
=
570 (pal_processor_state_info_t
*)peidx_psp(peidx
);
572 if (psp
->bc
&& pbci
->eb
&& pbci
->bsi
== 0) {
574 case 1: /* partial read */
575 case 3: /* full line(cpu) read */
576 case 9: /* I/O space read */
577 status
= recover_from_read_error(slidx
, peidx
, pbci
,
580 case 0: /* unknown */
581 case 2: /* partial write */
582 case 4: /* full line write */
583 case 5: /* implicit or explicit write-back operation */
584 case 6: /* snoop probe */
585 case 7: /* incoming or outgoing ptc.g */
586 case 8: /* write coalescing transactions */
587 case 10: /* I/O space write */
588 case 11: /* inter-processor interrupt message(IPI) */
589 case 12: /* interrupt acknowledge or
590 external task priority cycle */
594 } else if (psp
->cc
&& !psp
->bc
) { /* Cache error */
595 status
= recover_from_read_error(slidx
, peidx
, pbci
, sos
);
602 * recover_from_tlb_check
603 * @peidx: pointer of index of processor error section
606 * 1 on Success / 0 on Failure
609 recover_from_tlb_check(peidx_table_t
*peidx
)
611 sal_log_mod_error_info_t
*smei
;
612 pal_tlb_check_info_t
*ptci
;
614 smei
= (sal_log_mod_error_info_t
*)peidx_tlb_check(peidx
, 0);
615 ptci
= (pal_tlb_check_info_t
*)&(smei
->check_info
);
618 * Look for signature of a duplicate TLB DTC entry, which is
619 * a SW bug and always fatal.
621 if (ptci
->op
== PAL_TLB_CHECK_OP_PURGE
622 && !(ptci
->itr
|| ptci
->dtc
|| ptci
->itc
))
623 return fatal_mca("Duplicate TLB entry");
625 return mca_recovered("TLB check recovered");
629 * recover_from_processor_error
630 * @platform: whether there are some platform error section or not
631 * @slidx: pointer of index of SAL error record
632 * @peidx: pointer of index of processor error section
633 * @pbci: pointer of pal_bus_check_info
634 * @sos: pointer to hand off struct between SAL and OS
637 * 1 on Success / 0 on Failure
641 recover_from_processor_error(int platform
, slidx_table_t
*slidx
,
642 peidx_table_t
*peidx
, pal_bus_check_info_t
*pbci
,
643 struct ia64_sal_os_state
*sos
)
645 pal_processor_state_info_t
*psp
=
646 (pal_processor_state_info_t
*)peidx_psp(peidx
);
649 * Processor recovery status must key off of the PAL recovery
650 * status in the Processor State Parameter.
654 * The machine check is corrected.
657 return mca_recovered("machine check is already corrected.");
660 * The error was not contained. Software must be reset.
662 if (psp
->us
|| psp
->ci
== 0)
663 return fatal_mca("error not contained");
666 * Look for recoverable TLB check
668 if (psp
->tc
&& !(psp
->cc
|| psp
->bc
|| psp
->rc
|| psp
->uc
))
669 return recover_from_tlb_check(peidx
);
672 * The cache check and bus check bits have four possible states
674 * 1 1 Memory error, attempt recovery
675 * 1 0 Cache error, attempt recovery
676 * 0 1 I/O error, attempt recovery
677 * 0 0 Other error type, not recovered
679 if (psp
->cc
== 0 && (psp
->bc
== 0 || pbci
== NULL
))
680 return fatal_mca("No cache or bus check");
683 * Cannot handle more than one bus check.
685 if (peidx_bus_check_num(peidx
) > 1)
686 return fatal_mca("Too many bus checks");
689 return fatal_mca("Internal Bus error");
690 if (pbci
->eb
&& pbci
->bsi
> 0)
691 return fatal_mca("External bus check fatal status");
694 * This is a local MCA and estimated as a recoverable error.
697 return recover_from_platform_error(slidx
, peidx
, pbci
, sos
);
700 * On account of strange SAL error record, we cannot recover.
702 return fatal_mca("Strange SAL record");
706 * mca_try_to_recover - Try to recover from MCA
707 * @rec: pointer to a SAL error record
708 * @sos: pointer to hand off struct between SAL and OS
711 * 1 on Success / 0 on Failure
715 mca_try_to_recover(void *rec
, struct ia64_sal_os_state
*sos
)
721 pal_bus_check_info_t pbci
;
723 /* Make index of SAL error record */
724 platform_err
= mca_make_slidx(rec
, &slidx
);
726 /* Count processor error sections */
727 n_proc_err
= slidx_count(&slidx
, proc_err
);
729 /* Now, OS can recover when there is one processor error section */
731 return fatal_mca("Too Many Errors");
732 else if (n_proc_err
== 0)
733 /* Weird SAL record ... We can't do anything */
734 return fatal_mca("Weird SAL record");
736 /* Make index of processor error section */
737 mca_make_peidx((sal_log_processor_info_t
*)
738 slidx_first_entry(&slidx
.proc_err
)->hdr
, &peidx
);
740 /* Extract Processor BUS_CHECK[0] */
741 *((u64
*)&pbci
) = peidx_check_info(&peidx
, bus_check
, 0);
743 /* Check whether MCA is global or not */
744 if (is_mca_global(&peidx
, &pbci
, sos
))
745 return fatal_mca("global MCA");
747 /* Try to recover a processor error */
748 return recover_from_processor_error(platform_err
, &slidx
, &peidx
,
753 * =============================================================================
756 int __init
mca_external_handler_init(void)
758 if (init_record_index_pools())
761 /* register external mca handlers */
762 if (ia64_reg_MCA_extension(mca_try_to_recover
)) {
763 printk(KERN_ERR
"ia64_reg_MCA_extension failed.\n");
764 kfree(slidx_pool
.buffer
);
770 void __exit
mca_external_handler_exit(void)
772 /* unregister external mca handlers */
773 ia64_unreg_MCA_extension();
774 kfree(slidx_pool
.buffer
);
777 module_init(mca_external_handler_init
);
778 module_exit(mca_external_handler_exit
);
780 module_param(sal_rec_max
, int, 0644);
781 MODULE_PARM_DESC(sal_rec_max
, "Max size of SAL error record");
783 MODULE_DESCRIPTION("ia64 platform dependent mca handler driver");
784 MODULE_LICENSE("GPL");