LXR linux/arch/x86/kernel/msr.c

   1/* ----------------------------------------------------------------------- *
   2 *
   3 *   Copyright 2000-2008 H. Peter Anvin - All Rights Reserved
   4 *
   5 *   This program is free software; you can redistribute it and/or modify
   6 *   it under the terms of the GNU General Public License as published by
   7 *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
   8 *   USA; either version 2 of the License, or (at your option) any later
   9 *   version; incorporated herein by reference.
  10 *
  11 * ----------------------------------------------------------------------- */
  12
  13/*
  14 * x86 MSR access device
  15 *
  16 * This device is accessed by lseek() to the appropriate register number
  17 * and then read/write in chunks of 8 bytes.  A larger size means multiple
  18 * reads or writes of the same register.
  19 *
  20 * This driver uses /dev/cpu/%d/msr where %d is the minor number, and on
  21 * an SMP box will direct the access to CPU %d.
  22 */
  23
  24#include <linux/module.h>
  25
  26#include <linux/types.h>
  27#include <linux/errno.h>
  28#include <linux/fcntl.h>
  29#include <linux/init.h>
  30#include <linux/poll.h>
  31#include <linux/smp.h>
  32#include <linux/smp_lock.h>
  33#include <linux/major.h>
  34#include <linux/fs.h>
  35#include <linux/device.h>
  36#include <linux/cpu.h>
  37#include <linux/notifier.h>
  38
  39#include <asm/processor.h>
  40#include <asm/msr.h>
  41#include <asm/uaccess.h>
  42#include <asm/system.h>
  43
  44static struct class *msr_class;
  45
  46static loff_t msr_seek(struct file *file, loff_t offset, int orig)
  47{
  48        loff_t ret;
  49        struct inode *inode = file->f_mapping->host;
  50
  51        mutex_lock(&inode->i_mutex);
  52        switch (orig) {
  53        case 0:
  54                file->f_pos = offset;
  55                ret = file->f_pos;
  56                break;
  57        case 1:
  58                file->f_pos += offset;
  59                ret = file->f_pos;
  60                break;
  61        default:
  62                ret = -EINVAL;
  63        }
  64        mutex_unlock(&inode->i_mutex);
  65        return ret;
  66}
  67
  68static ssize_t msr_read(struct file *file, char __user *buf,
  69                        size_t count, loff_t *ppos)
  70{
  71        u32 __user *tmp = (u32 __user *) buf;
  72        u32 data[2];
  73        u32 reg = *ppos;
  74        int cpu = iminor(file->f_path.dentry->d_inode);
  75        int err = 0;
  76        ssize_t bytes = 0;
  77
  78        if (count % 8)
  79                return -EINVAL; /* Invalid chunk size */
  80
  81        for (; count; count -= 8) {
  82                err = rdmsr_safe_on_cpu(cpu, reg, &data[0], &data[1]);
  83                if (err) {
  84                        if (err == -EFAULT) /* Fix idiotic error code */
  85                                err = -EIO;
  86                        break;
  87                }
  88                if (copy_to_user(tmp, &data, 8)) {
  89                        err = -EFAULT;
  90                        break;
  91                }
  92                tmp += 2;
  93                bytes += 8;
  94        }
  95
  96        return bytes ? bytes : err;
  97}
  98
  99static ssize_t msr_write(struct file *file, const char __user *buf,
 100                         size_t count, loff_t *ppos)
 101{
 102        const u32 __user *tmp = (const u32 __user *)buf;
 103        u32 data[2];
 104        u32 reg = *ppos;
 105        int cpu = iminor(file->f_path.dentry->d_inode);
 106        int err = 0;
 107        ssize_t bytes = 0;
 108
 109        if (count % 8)
 110                return -EINVAL; /* Invalid chunk size */
 111
 112        for (; count; count -= 8) {
 113                if (copy_from_user(&data, tmp, 8)) {
 114                        err = -EFAULT;
 115                        break;
 116                }
 117                err = wrmsr_safe_on_cpu(cpu, reg, data[0], data[1]);
 118                if (err) {
 119                        if (err == -EFAULT) /* Fix idiotic error code */
 120                                err = -EIO;
 121                        break;
 122                }
 123                tmp += 2;
 124                bytes += 8;
 125        }
 126
 127        return bytes ? bytes : err;
 128}
 129
 130static int msr_open(struct inode *inode, struct file *file)
 131{
 132        unsigned int cpu = iminor(file->f_path.dentry->d_inode);
 133        struct cpuinfo_x86 *c = &cpu_data(cpu);
 134        int ret = 0;
 135
 136        lock_kernel();
 137        cpu = iminor(file->f_path.dentry->d_inode);
 138
 139        if (cpu >= NR_CPUS || !cpu_online(cpu)) {
 140                ret = -ENXIO;   /* No such CPU */
 141                goto out;
 142        }
 143        c = &cpu_data(cpu);
 144        if (!cpu_has(c, X86_FEATURE_MSR))
 145                ret = -EIO;     /* MSR not supported */
 146out:
 147        unlock_kernel();
 148        return ret;
 149}
 150
 151/*
 152 * File operations we support
 153 */
 154static const struct file_operations msr_fops = {
 155        .owner = THIS_MODULE,
 156        .llseek = msr_seek,
 157        .read = msr_read,
 158        .write = msr_write,
 159        .open = msr_open,
 160};
 161
 162static int __cpuinit msr_device_create(int cpu)
 163{
 164        struct device *dev;
 165
 166        dev = device_create(msr_class, NULL, MKDEV(MSR_MAJOR, cpu), NULL,
 167                            "msr%d", cpu);
 168        return IS_ERR(dev) ? PTR_ERR(dev) : 0;
 169}
 170
 171static void msr_device_destroy(int cpu)
 172{
 173        device_destroy(msr_class, MKDEV(MSR_MAJOR, cpu));
 174}
 175
 176static int __cpuinit msr_class_cpu_callback(struct notifier_block *nfb,
 177                                unsigned long action, void *hcpu)
 178{
 179        unsigned int cpu = (unsigned long)hcpu;
 180        int err = 0;
 181
 182        switch (action) {
 183        case CPU_UP_PREPARE:
 184                err = msr_device_create(cpu);
 185                break;
 186        case CPU_UP_CANCELED:
 187        case CPU_UP_CANCELED_FROZEN:
 188        case CPU_DEAD:
 189                msr_device_destroy(cpu);
 190                break;
 191        }
 192        return err ? NOTIFY_BAD : NOTIFY_OK;
 193}
 194
 195static struct notifier_block __refdata msr_class_cpu_notifier = {
 196        .notifier_call = msr_class_cpu_callback,
 197};
 198
 199static int __init msr_init(void)
 200{
 201        int i, err = 0;
 202        i = 0;
 203
 204        if (register_chrdev(MSR_MAJOR, "cpu/msr", &msr_fops)) {
 205                printk(KERN_ERR "msr: unable to get major %d for msr\n",
 206                       MSR_MAJOR);
 207                err = -EBUSY;
 208                goto out;
 209        }
 210        msr_class = class_create(THIS_MODULE, "msr");
 211        if (IS_ERR(msr_class)) {
 212                err = PTR_ERR(msr_class);
 213                goto out_chrdev;
 214        }
 215        for_each_online_cpu(i) {
 216                err = msr_device_create(i);
 217                if (err != 0)
 218                        goto out_class;
 219        }
 220        register_hotcpu_notifier(&msr_class_cpu_notifier);
 221
 222        err = 0;
 223        goto out;
 224
 225out_class:
 226        i = 0;
 227        for_each_online_cpu(i)
 228                msr_device_destroy(i);
 229        class_destroy(msr_class);
 230out_chrdev:
 231        unregister_chrdev(MSR_MAJOR, "cpu/msr");
 232out:
 233        return err;
 234}
 235
 236static void __exit msr_exit(void)
 237{
 238        int cpu = 0;
 239        for_each_online_cpu(cpu)
 240                msr_device_destroy(cpu);
 241        class_destroy(msr_class);
 242        unregister_chrdev(MSR_MAJOR, "cpu/msr");
 243        unregister_hotcpu_notifier(&msr_class_cpu_notifier);
 244}
 245
 246module_init(msr_init);
 247module_exit(msr_exit)
 248
 249MODULE_AUTHOR("H. Peter Anvin <hpa@zytor.com>");
 250MODULE_DESCRIPTION("x86 generic MSR driver");
 251MODULE_LICENSE("GPL");
 252