arch/x86/kernel/cpu/mcheck/dev-mcelog.c

   1 /*
   2  * /dev/mcelog driver
   3  *
   4  * K8 parts Copyright 2002,2003 Andi Kleen, SuSE Labs.
   5  * Rest from unknown author(s).
   6  * 2004 Andi Kleen. Rewrote most of it.
   7  * Copyright 2008 Intel Corporation
   8  * Author: Andi Kleen
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/miscdevice.h>
  14 #include <linux/slab.h>
  15 #include <linux/kmod.h>
  16 #include <linux/poll.h>
  17
  18 #include "mce-internal.h"
  19
  20 static BLOCKING_NOTIFIER_HEAD(mce_injector_chain);
  21
  22 static DEFINE_MUTEX(mce_chrdev_read_mutex);
  23
  24 static char mce_helper[128];
  25 static char *mce_helper_argv[2] = { mce_helper, NULL };
  26
  27 /*
  28  * Lockless MCE logging infrastructure.
  29  * This avoids deadlocks on printk locks without having to break locks. Also
  30  * separate MCEs from kernel messages to avoid bogus bug reports.
  31  */
  32
  33 static struct mce_log_buffer mcelog = {
  34         .signature      = MCE_LOG_SIGNATURE,
  35         .len            = MCE_LOG_LEN,
  36         .recordlen      = sizeof(struct mce),
  37 };
  38
  39 static DECLARE_WAIT_QUEUE_HEAD(mce_chrdev_wait);
  40
  41 static int dev_mce_log(struct notifier_block *nb, unsigned long val,
  42                                 void *data)
  43 {
  44         struct mce *mce = (struct mce *)data;
  45         unsigned int entry;
  46
  47         mutex_lock(&mce_chrdev_read_mutex);
  48
  49         entry = mcelog.next;
  50
  51         /*
  52          * When the buffer fills up discard new entries. Assume that the
  53          * earlier errors are the more interesting ones:
  54          */
  55         if (entry >= MCE_LOG_LEN) {
  56                 set_bit(MCE_OVERFLOW, (unsigned long *)&mcelog.flags);
  57                 goto unlock;
  58         }
  59
  60         mcelog.next = entry + 1;
  61
  62         memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
  63         mcelog.entry[entry].finished = 1;
  64
  65         /* wake processes polling /dev/mcelog */
  66         wake_up_interruptible(&mce_chrdev_wait);
  67
  68 unlock:
  69         mutex_unlock(&mce_chrdev_read_mutex);
  70
  71         return NOTIFY_OK;
  72 }
  73
  74 static struct notifier_block dev_mcelog_nb = {
  75         .notifier_call  = dev_mce_log,
  76         .priority       = MCE_PRIO_MCELOG,
  77 };
  78
  79 static void mce_do_trigger(struct work_struct *work)
  80 {
  81         call_usermodehelper(mce_helper, mce_helper_argv, NULL, UMH_NO_WAIT);
  82 }
  83
  84 static DECLARE_WORK(mce_trigger_work, mce_do_trigger);
  85
  86
  87 void mce_work_trigger(void)
  88 {
  89         if (mce_helper[0])
  90                 schedule_work(&mce_trigger_work);
  91 }
  92
  93 static ssize_t
  94 show_trigger(struct device *s, struct device_attribute *attr, char *buf)
  95 {
  96         strcpy(buf, mce_helper);
  97         strcat(buf, "\n");
  98         return strlen(mce_helper) + 1;
  99 }
 100
 101 static ssize_t set_trigger(struct device *s, struct device_attribute *attr,
 102                                 const char *buf, size_t siz)
 103 {
 104         char *p;
 105
 106         strncpy(mce_helper, buf, sizeof(mce_helper));
 107         mce_helper[sizeof(mce_helper)-1] = 0;
 108         p = strchr(mce_helper, '\n');
 109
 110         if (p)
 111                 *p = 0;
 112
 113         return strlen(mce_helper) + !!p;
 114 }
 115
 116 DEVICE_ATTR(trigger, 0644, show_trigger, set_trigger);
 117
 118 /*
 119  * mce_chrdev: Character device /dev/mcelog to read and clear the MCE log.
 120  */
 121
 122 static DEFINE_SPINLOCK(mce_chrdev_state_lock);
 123 static int mce_chrdev_open_count;       /* #times opened */
 124 static int mce_chrdev_open_exclu;       /* already open exclusive? */
 125
 126 static int mce_chrdev_open(struct inode *inode, struct file *file)
 127 {
 128         spin_lock(&mce_chrdev_state_lock);
 129
 130         if (mce_chrdev_open_exclu ||
 131             (mce_chrdev_open_count && (file->f_flags & O_EXCL))) {
 132                 spin_unlock(&mce_chrdev_state_lock);
 133
 134                 return -EBUSY;
 135         }
 136
 137         if (file->f_flags & O_EXCL)
 138                 mce_chrdev_open_exclu = 1;
 139         mce_chrdev_open_count++;
 140
 141         spin_unlock(&mce_chrdev_state_lock);
 142
 143         return nonseekable_open(inode, file);
 144 }
 145
 146 static int mce_chrdev_release(struct inode *inode, struct file *file)
 147 {
 148         spin_lock(&mce_chrdev_state_lock);
 149
 150         mce_chrdev_open_count--;
 151         mce_chrdev_open_exclu = 0;
 152
 153         spin_unlock(&mce_chrdev_state_lock);
 154
 155         return 0;
 156 }
 157
 158 static int mce_apei_read_done;
 159
 160 /* Collect MCE record of previous boot in persistent storage via APEI ERST. */
 161 static int __mce_read_apei(char __user **ubuf, size_t usize)
 162 {
 163         int rc;
 164         u64 record_id;
 165         struct mce m;
 166
 167         if (usize < sizeof(struct mce))
 168                 return -EINVAL;
 169
 170         rc = apei_read_mce(&m, &record_id);
 171         /* Error or no more MCE record */
 172         if (rc <= 0) {
 173                 mce_apei_read_done = 1;
 174                 /*
 175                  * When ERST is disabled, mce_chrdev_read() should return
 176                  * "no record" instead of "no device."
 177                  */
 178                 if (rc == -ENODEV)
 179                         return 0;
 180                 return rc;
 181         }
 182         rc = -EFAULT;
 183         if (copy_to_user(*ubuf, &m, sizeof(struct mce)))
 184                 return rc;
 185         /*
 186          * In fact, we should have cleared the record after that has
 187          * been flushed to the disk or sent to network in
 188          * /sbin/mcelog, but we have no interface to support that now,
 189          * so just clear it to avoid duplication.
 190          */
 191         rc = apei_clear_mce(record_id);
 192         if (rc) {
 193                 mce_apei_read_done = 1;
 194                 return rc;
 195         }
 196         *ubuf += sizeof(struct mce);
 197
 198         return 0;
 199 }
 200
 201 static ssize_t mce_chrdev_read(struct file *filp, char __user *ubuf,
 202                                 size_t usize, loff_t *off)
 203 {
 204         char __user *buf = ubuf;
 205         unsigned next;
 206         int i, err;
 207
 208         mutex_lock(&mce_chrdev_read_mutex);
 209
 210         if (!mce_apei_read_done) {
 211                 err = __mce_read_apei(&buf, usize);
 212                 if (err || buf != ubuf)
 213                         goto out;
 214         }
 215
 216         /* Only supports full reads right now */
 217         err = -EINVAL;
 218         if (*off != 0 || usize < MCE_LOG_LEN*sizeof(struct mce))
 219                 goto out;
 220
 221         next = mcelog.next;
 222         err = 0;
 223
 224         for (i = 0; i < next; i++) {
 225                 struct mce *m = &mcelog.entry[i];
 226
 227                 err |= copy_to_user(buf, m, sizeof(*m));
 228                 buf += sizeof(*m);
 229         }
 230
 231         memset(mcelog.entry, 0, next * sizeof(struct mce));
 232         mcelog.next = 0;
 233
 234         if (err)
 235                 err = -EFAULT;
 236
 237 out:
 238         mutex_unlock(&mce_chrdev_read_mutex);
 239
 240         return err ? err : buf - ubuf;
 241 }
 242
 243 static __poll_t mce_chrdev_poll(struct file *file, poll_table *wait)
 244 {
 245         poll_wait(file, &mce_chrdev_wait, wait);
 246         if (READ_ONCE(mcelog.next))
 247                 return EPOLLIN | EPOLLRDNORM;
 248         if (!mce_apei_read_done && apei_check_mce())
 249                 return EPOLLIN | EPOLLRDNORM;
 250         return 0;
 251 }
 252
 253 static long mce_chrdev_ioctl(struct file *f, unsigned int cmd,
 254                                 unsigned long arg)
 255 {
 256         int __user *p = (int __user *)arg;
 257
 258         if (!capable(CAP_SYS_ADMIN))
 259                 return -EPERM;
 260
 261         switch (cmd) {
 262         case MCE_GET_RECORD_LEN:
 263                 return put_user(sizeof(struct mce), p);
 264         case MCE_GET_LOG_LEN:
 265                 return put_user(MCE_LOG_LEN, p);
 266         case MCE_GETCLEAR_FLAGS: {
 267                 unsigned flags;
 268
 269                 do {
 270                         flags = mcelog.flags;
 271                 } while (cmpxchg(&mcelog.flags, flags, 0) != flags);
 272
 273                 return put_user(flags, p);
 274         }
 275         default:
 276                 return -ENOTTY;
 277         }
 278 }
 279
 280 void mce_register_injector_chain(struct notifier_block *nb)
 281 {
 282         blocking_notifier_chain_register(&mce_injector_chain, nb);
 283 }
 284 EXPORT_SYMBOL_GPL(mce_register_injector_chain);
 285
 286 void mce_unregister_injector_chain(struct notifier_block *nb)
 287 {
 288         blocking_notifier_chain_unregister(&mce_injector_chain, nb);
 289 }
 290 EXPORT_SYMBOL_GPL(mce_unregister_injector_chain);
 291
 292 static ssize_t mce_chrdev_write(struct file *filp, const char __user *ubuf,
 293                                 size_t usize, loff_t *off)
 294 {
 295         struct mce m;
 296
 297         if (!capable(CAP_SYS_ADMIN))
 298                 return -EPERM;
 299         /*
 300          * There are some cases where real MSR reads could slip
 301          * through.
 302          */
 303         if (!boot_cpu_has(X86_FEATURE_MCE) || !boot_cpu_has(X86_FEATURE_MCA))
 304                 return -EIO;
 305
 306         if ((unsigned long)usize > sizeof(struct mce))
 307                 usize = sizeof(struct mce);
 308         if (copy_from_user(&m, ubuf, usize))
 309                 return -EFAULT;
 310
 311         if (m.extcpu >= num_possible_cpus() || !cpu_online(m.extcpu))
 312                 return -EINVAL;
 313
 314         /*
 315          * Need to give user space some time to set everything up,
 316          * so do it a jiffie or two later everywhere.
 317          */
 318         schedule_timeout(2);
 319
 320         blocking_notifier_call_chain(&mce_injector_chain, 0, &m);
 321
 322         return usize;
 323 }
 324
 325 static const struct file_operations mce_chrdev_ops = {
 326         .open                   = mce_chrdev_open,
 327         .release                = mce_chrdev_release,
 328         .read                   = mce_chrdev_read,
 329         .write                  = mce_chrdev_write,
 330         .poll                   = mce_chrdev_poll,
 331         .unlocked_ioctl         = mce_chrdev_ioctl,
 332         .llseek                 = no_llseek,
 333 };
 334
 335 static struct miscdevice mce_chrdev_device = {
 336         MISC_MCELOG_MINOR,
 337         "mcelog",
 338         &mce_chrdev_ops,
 339 };
 340
 341 static __init int dev_mcelog_init_device(void)
 342 {
 343         int err;
 344
 345         /* register character device /dev/mcelog */
 346         err = misc_register(&mce_chrdev_device);
 347         if (err) {
 348                 if (err == -EBUSY)
 349                         /* Xen dom0 might have registered the device already. */
 350                         pr_info("Unable to init device /dev/mcelog, already registered");
 351                 else
 352                         pr_err("Unable to init device /dev/mcelog (rc: %d)\n", err);
 353
 354                 return err;
 355         }
 356
 357         mce_register_decode_chain(&dev_mcelog_nb);
 358         return 0;
 359 }
 360 device_initcall_sync(dev_mcelog_init_device);