]>
Commit | Line | Data |
---|---|---|
817f32d0 AK |
1 | /* |
2 | * MCE grading rules. | |
3 | * Copyright 2008, 2009 Intel Corporation. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License | |
7 | * as published by the Free Software Foundation; version 2 | |
8 | * of the License. | |
9 | * | |
10 | * Author: Andi Kleen | |
11 | */ | |
12 | #include <linux/kernel.h> | |
4611a6fa HY |
13 | #include <linux/seq_file.h> |
14 | #include <linux/init.h> | |
15 | #include <linux/debugfs.h> | |
817f32d0 AK |
16 | #include <asm/mce.h> |
17 | ||
18 | #include "mce-internal.h" | |
19 | ||
20 | /* | |
21 | * Grade an mce by severity. In general the most severe ones are processed | |
22 | * first. Since there are quite a lot of combinations test the bits in a | |
23 | * table-driven way. The rules are simply processed in order, first | |
24 | * match wins. | |
ed7290d0 AK |
25 | * |
26 | * Note this is only used for machine check exceptions, the corrected | |
27 | * errors use much simpler rules. The exceptions still check for the corrected | |
28 | * errors, but only to leave them alone for the CMCI handler (except for | |
29 | * panic situations) | |
817f32d0 AK |
30 | */ |
31 | ||
ed7290d0 AK |
32 | enum context { IN_KERNEL = 1, IN_USER = 2 }; |
33 | enum ser { SER_REQUIRED = 1, NO_SER = 2 }; | |
34 | ||
817f32d0 AK |
35 | static struct severity { |
36 | u64 mask; | |
37 | u64 result; | |
38 | unsigned char sev; | |
39 | unsigned char mcgmask; | |
40 | unsigned char mcgres; | |
ed7290d0 AK |
41 | unsigned char ser; |
42 | unsigned char context; | |
4611a6fa | 43 | unsigned char covered; |
817f32d0 AK |
44 | char *msg; |
45 | } severities[] = { | |
a17957cd HS |
46 | #define MCESEV(s, m, c...) { .sev = MCE_ ## s ## _SEVERITY, .msg = m, ## c } |
47 | #define KERNEL .context = IN_KERNEL | |
48 | #define USER .context = IN_USER | |
49 | #define SER .ser = SER_REQUIRED | |
50 | #define NOSER .ser = NO_SER | |
51 | #define BITCLR(x) .mask = x, .result = 0 | |
52 | #define BITSET(x) .mask = x, .result = x | |
53 | #define MCGMASK(x, y) .mcgmask = x, .mcgres = y | |
54 | #define MASK(x, y) .mask = x, .result = y | |
ed7290d0 AK |
55 | #define MCI_UC_S (MCI_STATUS_UC|MCI_STATUS_S) |
56 | #define MCI_UC_SAR (MCI_STATUS_UC|MCI_STATUS_S|MCI_STATUS_AR) | |
57 | #define MCACOD 0xffff | |
58 | ||
a17957cd HS |
59 | MCESEV( |
60 | NO, "Invalid", | |
61 | BITCLR(MCI_STATUS_VAL) | |
901d7691 | 62 | ), |
a17957cd HS |
63 | MCESEV( |
64 | NO, "Not enabled", | |
65 | BITCLR(MCI_STATUS_EN) | |
901d7691 | 66 | ), |
a17957cd HS |
67 | MCESEV( |
68 | PANIC, "Processor context corrupt", | |
69 | BITSET(MCI_STATUS_PCC) | |
901d7691 | 70 | ), |
ed7290d0 | 71 | /* When MCIP is not set something is very confused */ |
a17957cd HS |
72 | MCESEV( |
73 | PANIC, "MCIP not set in MCA handler", | |
74 | MCGMASK(MCG_STATUS_MCIP, 0) | |
901d7691 | 75 | ), |
ed7290d0 | 76 | /* Neither return not error IP -- no chance to recover -> PANIC */ |
a17957cd HS |
77 | MCESEV( |
78 | PANIC, "Neither restart nor error IP", | |
79 | MCGMASK(MCG_STATUS_RIPV|MCG_STATUS_EIPV, 0) | |
901d7691 | 80 | ), |
a17957cd | 81 | MCESEV( |
901d7691 | 82 | PANIC, "In kernel and no restart IP", |
a17957cd | 83 | KERNEL, MCGMASK(MCG_STATUS_RIPV, 0) |
901d7691 | 84 | ), |
a17957cd | 85 | MCESEV( |
901d7691 | 86 | KEEP, "Corrected error", |
a17957cd | 87 | NOSER, BITCLR(MCI_STATUS_UC) |
901d7691 | 88 | ), |
ed7290d0 AK |
89 | |
90 | /* ignore OVER for UCNA */ | |
a17957cd | 91 | MCESEV( |
901d7691 | 92 | KEEP, "Uncorrected no action required", |
a17957cd | 93 | SER, MASK(MCI_UC_SAR, MCI_STATUS_UC) |
901d7691 | 94 | ), |
a17957cd | 95 | MCESEV( |
901d7691 | 96 | PANIC, "Illegal combination (UCNA with AR=1)", |
a17957cd HS |
97 | SER, |
98 | MASK(MCI_STATUS_OVER|MCI_UC_SAR, MCI_STATUS_UC|MCI_STATUS_AR) | |
901d7691 | 99 | ), |
a17957cd | 100 | MCESEV( |
901d7691 | 101 | KEEP, "Non signalled machine check", |
7639bfc7 | 102 | SER, BITCLR(MCI_STATUS_S) |
901d7691 | 103 | ), |
ed7290d0 AK |
104 | |
105 | /* AR add known MCACODs here */ | |
a17957cd | 106 | MCESEV( |
901d7691 | 107 | PANIC, "Action required with lost events", |
7639bfc7 | 108 | SER, BITSET(MCI_STATUS_OVER|MCI_UC_SAR) |
901d7691 | 109 | ), |
a17957cd | 110 | MCESEV( |
7639bfc7 | 111 | PANIC, "Action required: unknown MCACOD", |
a17957cd | 112 | SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR, MCI_UC_SAR) |
901d7691 | 113 | ), |
ed7290d0 AK |
114 | |
115 | /* known AO MCACODs: */ | |
a17957cd | 116 | MCESEV( |
901d7691 | 117 | AO, "Action optional: memory scrubbing error", |
7639bfc7 | 118 | SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR|0xfff0, MCI_UC_S|0x00c0) |
901d7691 | 119 | ), |
a17957cd | 120 | MCESEV( |
901d7691 | 121 | AO, "Action optional: last level cache writeback error", |
7639bfc7 | 122 | SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR|MCACOD, MCI_UC_S|0x017a) |
901d7691 | 123 | ), |
a17957cd | 124 | MCESEV( |
7639bfc7 | 125 | SOME, "Action optional: unknown MCACOD", |
a17957cd | 126 | SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR, MCI_UC_S) |
901d7691 | 127 | ), |
a17957cd | 128 | MCESEV( |
901d7691 | 129 | SOME, "Action optional with lost events", |
7639bfc7 | 130 | SER, MASK(MCI_STATUS_OVER|MCI_UC_SAR, MCI_STATUS_OVER|MCI_UC_S) |
901d7691 | 131 | ), |
a17957cd HS |
132 | |
133 | MCESEV( | |
134 | PANIC, "Overflowed uncorrected", | |
7639bfc7 | 135 | BITSET(MCI_STATUS_OVER|MCI_STATUS_UC) |
901d7691 | 136 | ), |
a17957cd HS |
137 | MCESEV( |
138 | UC, "Uncorrected", | |
139 | BITSET(MCI_STATUS_UC) | |
901d7691 | 140 | ), |
a17957cd HS |
141 | MCESEV( |
142 | SOME, "No match", | |
143 | BITSET(0) | |
901d7691 | 144 | ) /* always matches. keep at end */ |
817f32d0 AK |
145 | }; |
146 | ||
ed7290d0 AK |
147 | /* |
148 | * If the EIPV bit is set, it means the saved IP is the | |
149 | * instruction which caused the MCE. | |
150 | */ | |
151 | static int error_context(struct mce *m) | |
152 | { | |
153 | if (m->mcgstatus & MCG_STATUS_EIPV) | |
154 | return (m->ip && (m->cs & 3) == 3) ? IN_USER : IN_KERNEL; | |
155 | /* Unknown, assume kernel */ | |
156 | return IN_KERNEL; | |
157 | } | |
158 | ||
7639bfc7 | 159 | int mce_severity(struct mce *m, int tolerant, char **msg) |
817f32d0 | 160 | { |
7639bfc7 | 161 | enum context ctx = error_context(m); |
817f32d0 | 162 | struct severity *s; |
ed7290d0 | 163 | |
817f32d0 | 164 | for (s = severities;; s++) { |
7639bfc7 | 165 | if ((m->status & s->mask) != s->result) |
817f32d0 | 166 | continue; |
7639bfc7 | 167 | if ((m->mcgstatus & s->mcgmask) != s->mcgres) |
817f32d0 | 168 | continue; |
ed7290d0 AK |
169 | if (s->ser == SER_REQUIRED && !mce_ser) |
170 | continue; | |
171 | if (s->ser == NO_SER && mce_ser) | |
172 | continue; | |
173 | if (s->context && ctx != s->context) | |
174 | continue; | |
817f32d0 AK |
175 | if (msg) |
176 | *msg = s->msg; | |
4611a6fa | 177 | s->covered = 1; |
ed7290d0 AK |
178 | if (s->sev >= MCE_UC_SEVERITY && ctx == IN_KERNEL) { |
179 | if (panic_on_oops || tolerant < 1) | |
180 | return MCE_PANIC_SEVERITY; | |
181 | } | |
817f32d0 AK |
182 | return s->sev; |
183 | } | |
184 | } | |
4611a6fa | 185 | |
e34e77ce | 186 | #ifdef CONFIG_DEBUG_FS |
4611a6fa HY |
187 | static void *s_start(struct seq_file *f, loff_t *pos) |
188 | { | |
189 | if (*pos >= ARRAY_SIZE(severities)) | |
190 | return NULL; | |
191 | return &severities[*pos]; | |
192 | } | |
193 | ||
194 | static void *s_next(struct seq_file *f, void *data, loff_t *pos) | |
195 | { | |
196 | if (++(*pos) >= ARRAY_SIZE(severities)) | |
197 | return NULL; | |
198 | return &severities[*pos]; | |
199 | } | |
200 | ||
201 | static void s_stop(struct seq_file *f, void *data) | |
202 | { | |
203 | } | |
204 | ||
205 | static int s_show(struct seq_file *f, void *data) | |
206 | { | |
207 | struct severity *ser = data; | |
208 | seq_printf(f, "%d\t%s\n", ser->covered, ser->msg); | |
209 | return 0; | |
210 | } | |
211 | ||
212 | static const struct seq_operations severities_seq_ops = { | |
213 | .start = s_start, | |
214 | .next = s_next, | |
215 | .stop = s_stop, | |
216 | .show = s_show, | |
217 | }; | |
218 | ||
219 | static int severities_coverage_open(struct inode *inode, struct file *file) | |
220 | { | |
221 | return seq_open(file, &severities_seq_ops); | |
222 | } | |
223 | ||
224 | static ssize_t severities_coverage_write(struct file *file, | |
225 | const char __user *ubuf, | |
226 | size_t count, loff_t *ppos) | |
227 | { | |
228 | int i; | |
229 | for (i = 0; i < ARRAY_SIZE(severities); i++) | |
230 | severities[i].covered = 0; | |
231 | return count; | |
232 | } | |
233 | ||
234 | static const struct file_operations severities_coverage_fops = { | |
235 | .open = severities_coverage_open, | |
236 | .release = seq_release, | |
237 | .read = seq_read, | |
238 | .write = severities_coverage_write, | |
6038f373 | 239 | .llseek = seq_lseek, |
4611a6fa HY |
240 | }; |
241 | ||
242 | static int __init severities_debugfs_init(void) | |
243 | { | |
7639bfc7 | 244 | struct dentry *dmce, *fsev; |
4611a6fa | 245 | |
5be9ed25 | 246 | dmce = mce_get_debugfs_dir(); |
7639bfc7 | 247 | if (!dmce) |
4611a6fa | 248 | goto err_out; |
7639bfc7 HS |
249 | |
250 | fsev = debugfs_create_file("severities-coverage", 0444, dmce, NULL, | |
251 | &severities_coverage_fops); | |
252 | if (!fsev) | |
4611a6fa HY |
253 | goto err_out; |
254 | ||
255 | return 0; | |
256 | ||
257 | err_out: | |
4611a6fa HY |
258 | return -ENOMEM; |
259 | } | |
260 | late_initcall(severities_debugfs_init); | |
7639bfc7 | 261 | #endif /* CONFIG_DEBUG_FS */ |