1 // SPDX-License-Identifier: GPL-2.0-only
5 * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
6 * Rest from unknown author(s).
7 * 2004 Andi Kleen. Rewrote most of it.
8 * Copyright 2008 Intel Corporation
12 #include <linux/miscdevice.h>
13 #include <linux/slab.h>
14 #include <linux/kmod.h>
15 #include <linux/poll.h>
19 static BLOCKING_NOTIFIER_HEAD(mce_injector_chain);
21 static DEFINE_MUTEX(mce_chrdev_read_mutex);
23 static char mce_helper[128];
24 static char *mce_helper_argv[2] = { mce_helper, NULL };
27 * Lockless MCE logging infrastructure.
28 * This avoids deadlocks on printk locks without having to break locks. Also
29 * separate MCEs from kernel messages to avoid bogus bug reports.
32 static struct mce_log_buffer *mcelog;
34 static DECLARE_WAIT_QUEUE_HEAD(mce_chrdev_wait);
36 static int dev_mce_log(struct notifier_block *nb, unsigned long val,
39 struct mce *mce = (struct mce *)data;
42 if (mce->kflags & MCE_HANDLED_CEC)
45 mutex_lock(&mce_chrdev_read_mutex);
50 * When the buffer fills up discard new entries. Assume that the
51 * earlier errors are the more interesting ones:
53 if (entry >= mcelog->len) {
54 set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog->flags);
58 mcelog->next = entry + 1;
60 memcpy(mcelog->entry + entry, mce, sizeof(struct mce));
61 mcelog->entry[entry].finished = 1;
62 mcelog->entry[entry].kflags = 0;
64 /* wake processes polling /dev/mcelog */
65 wake_up_interruptible(&mce_chrdev_wait);
68 mutex_unlock(&mce_chrdev_read_mutex);
70 if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
71 mce->kflags |= MCE_HANDLED_MCELOG;
76 static struct notifier_block dev_mcelog_nb = {
77 .notifier_call = dev_mce_log,
78 .priority = MCE_PRIO_MCELOG,
81 static void mce_do_trigger(struct work_struct *work)
83 call_usermodehelper(mce_helper, mce_helper_argv, NULL, UMH_NO_WAIT);
86 static DECLARE_WORK(mce_trigger_work, mce_do_trigger);
89 void mce_work_trigger(void)
92 schedule_work(&mce_trigger_work);
96 show_trigger(struct device *s, struct device_attribute *attr, char *buf)
98 strcpy(buf, mce_helper);
100 return strlen(mce_helper) + 1;
103 static ssize_t set_trigger(struct device *s, struct device_attribute *attr,
104 const char *buf, size_t siz)
108 strncpy(mce_helper, buf, sizeof(mce_helper));
109 mce_helper[sizeof(mce_helper)-1] = 0;
110 p = strchr(mce_helper, '\n');
115 return strlen(mce_helper) + !!p;
118 DEVICE_ATTR(trigger, 0644, show_trigger, set_trigger);
121 * mce_chrdev: Character device /dev/mcelog to read and clear the MCE log.
124 static DEFINE_SPINLOCK(mce_chrdev_state_lock);
125 static int mce_chrdev_open_count; /* #times opened */
126 static int mce_chrdev_open_exclu; /* already open exclusive? */
128 static int mce_chrdev_open(struct inode *inode, struct file *file)
130 spin_lock(&mce_chrdev_state_lock);
132 if (mce_chrdev_open_exclu ||
133 (mce_chrdev_open_count && (file->f_flags & O_EXCL))) {
134 spin_unlock(&mce_chrdev_state_lock);
139 if (file->f_flags & O_EXCL)
140 mce_chrdev_open_exclu = 1;
141 mce_chrdev_open_count++;
143 spin_unlock(&mce_chrdev_state_lock);
145 return nonseekable_open(inode, file);
148 static int mce_chrdev_release(struct inode *inode, struct file *file)
150 spin_lock(&mce_chrdev_state_lock);
152 mce_chrdev_open_count--;
153 mce_chrdev_open_exclu = 0;
155 spin_unlock(&mce_chrdev_state_lock);
160 static int mce_apei_read_done;
162 /* Collect MCE record of previous boot in persistent storage via APEI ERST. */
163 static int __mce_read_apei(char __user **ubuf, size_t usize)
169 if (usize < sizeof(struct mce))
172 rc = apei_read_mce(&m, &record_id);
173 /* Error or no more MCE record */
175 mce_apei_read_done = 1;
177 * When ERST is disabled, mce_chrdev_read() should return
178 * "no record" instead of "no device."
185 if (copy_to_user(*ubuf, &m, sizeof(struct mce)))
188 * In fact, we should have cleared the record after that has
189 * been flushed to the disk or sent to network in
190 * /sbin/mcelog, but we have no interface to support that now,
191 * so just clear it to avoid duplication.
193 rc = apei_clear_mce(record_id);
195 mce_apei_read_done = 1;
198 *ubuf += sizeof(struct mce);
203 static ssize_t mce_chrdev_read(struct file *filp, char __user *ubuf,
204 size_t usize, loff_t *off)
206 char __user *buf = ubuf;
210 mutex_lock(&mce_chrdev_read_mutex);
212 if (!mce_apei_read_done) {
213 err = __mce_read_apei(&buf, usize);
214 if (err || buf != ubuf)
218 /* Only supports full reads right now */
220 if (*off != 0 || usize < mcelog->len * sizeof(struct mce))
226 for (i = 0; i < next; i++) {
227 struct mce *m = &mcelog->entry[i];
229 err |= copy_to_user(buf, m, sizeof(*m));
233 memset(mcelog->entry, 0, next * sizeof(struct mce));
240 mutex_unlock(&mce_chrdev_read_mutex);
242 return err ? err : buf - ubuf;
245 static __poll_t mce_chrdev_poll(struct file *file, poll_table *wait)
247 poll_wait(file, &mce_chrdev_wait, wait);
248 if (READ_ONCE(mcelog->next))
249 return EPOLLIN | EPOLLRDNORM;
250 if (!mce_apei_read_done && apei_check_mce())
251 return EPOLLIN | EPOLLRDNORM;
255 static long mce_chrdev_ioctl(struct file *f, unsigned int cmd,
258 int __user *p = (int __user *)arg;
260 if (!capable(CAP_SYS_ADMIN))
264 case MCE_GET_RECORD_LEN:
265 return put_user(sizeof(struct mce), p);
266 case MCE_GET_LOG_LEN:
267 return put_user(mcelog->len, p);
268 case MCE_GETCLEAR_FLAGS: {
272 flags = mcelog->flags;
273 } while (cmpxchg(&mcelog->flags, flags, 0) != flags);
275 return put_user(flags, p);
282 void mce_register_injector_chain(struct notifier_block *nb)
284 blocking_notifier_chain_register(&mce_injector_chain, nb);
286 EXPORT_SYMBOL_GPL(mce_register_injector_chain);
288 void mce_unregister_injector_chain(struct notifier_block *nb)
290 blocking_notifier_chain_unregister(&mce_injector_chain, nb);
292 EXPORT_SYMBOL_GPL(mce_unregister_injector_chain);
294 static ssize_t mce_chrdev_write(struct file *filp, const char __user *ubuf,
295 size_t usize, loff_t *off)
299 if (!capable(CAP_SYS_ADMIN))
302 * There are some cases where real MSR reads could slip
305 if (!boot_cpu_has(X86_FEATURE_MCE) || !boot_cpu_has(X86_FEATURE_MCA))
308 if ((unsigned long)usize > sizeof(struct mce))
309 usize = sizeof(struct mce);
310 if (copy_from_user(&m, ubuf, usize))
313 if (m.extcpu >= num_possible_cpus() || !cpu_online(m.extcpu))
317 * Need to give user space some time to set everything up,
318 * so do it a jiffie or two later everywhere.
322 blocking_notifier_call_chain(&mce_injector_chain, 0, &m);
327 static const struct file_operations mce_chrdev_ops = {
328 .open = mce_chrdev_open,
329 .release = mce_chrdev_release,
330 .read = mce_chrdev_read,
331 .write = mce_chrdev_write,
332 .poll = mce_chrdev_poll,
333 .unlocked_ioctl = mce_chrdev_ioctl,
334 .compat_ioctl = compat_ptr_ioctl,
338 static struct miscdevice mce_chrdev_device = {
344 static __init int dev_mcelog_init_device(void)
349 mce_log_len = max(MCE_LOG_MIN_LEN, num_online_cpus());
350 mcelog = kzalloc(struct_size(mcelog, entry, mce_log_len), GFP_KERNEL);
354 memcpy(mcelog->signature, MCE_LOG_SIGNATURE, sizeof(mcelog->signature));
355 mcelog->len = mce_log_len;
356 mcelog->recordlen = sizeof(struct mce);
358 /* register character device /dev/mcelog */
359 err = misc_register(&mce_chrdev_device);
362 /* Xen dom0 might have registered the device already. */
363 pr_info("Unable to init device /dev/mcelog, already registered");
365 pr_err("Unable to init device /dev/mcelog (rc: %d)\n", err);
371 mce_register_decode_chain(&dev_mcelog_nb);
374 device_initcall_sync(dev_mcelog_init_device);