arch/i386/kernel/cpu/mtrr/if.c

   1 #include <linux/init.h>
   2 #include <linux/proc_fs.h>
   3 #include <linux/ctype.h>
   4 #include <linux/module.h>
   5 #include <linux/seq_file.h>
   6 #include <asm/uaccess.h>
   7
   8 #define LINE_SIZE 80
   9
  10 #include <asm/mtrr.h>
  11 #include "mtrr.h"
  12
  13 /* RED-PEN: this is accessed without any locking */
  14 extern unsigned int *usage_table;
  15
  16
  17 #define FILE_FCOUNT(f) (((struct seq_file *)((f)->private_data))->private)
  18
  19 static char *mtrr_strings[MTRR_NUM_TYPES] =
  20 {
  21     "uncachable",               /* 0 */
  22     "write-combining",          /* 1 */
  23     "?",                        /* 2 */
  24     "?",                        /* 3 */
  25     "write-through",            /* 4 */
  26     "write-protect",            /* 5 */
  27     "write-back",               /* 6 */
  28 };
  29
  30 char *mtrr_attrib_to_str(int x)
  31 {
  32         return (x <= 6) ? mtrr_strings[x] : "?";
  33 }
  34
  35 #ifdef CONFIG_PROC_FS
  36
  37 static int
  38 mtrr_file_add(unsigned long base, unsigned long size,
  39               unsigned int type, char increment, struct file *file, int page)
  40 {
  41         int reg, max;
  42         unsigned int *fcount = FILE_FCOUNT(file);
  43
  44         max = num_var_ranges;
  45         if (fcount == NULL) {
  46                 fcount = kmalloc(max * sizeof *fcount, GFP_KERNEL);
  47                 if (!fcount)
  48                         return -ENOMEM;
  49                 memset(fcount, 0, max * sizeof *fcount);
  50                 FILE_FCOUNT(file) = fcount;
  51         }
  52         if (!page) {
  53                 if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)))
  54                         return -EINVAL;
  55                 base >>= PAGE_SHIFT;
  56                 size >>= PAGE_SHIFT;
  57         }
  58         reg = mtrr_add_page(base, size, type, 1);
  59         if (reg >= 0)
  60                 ++fcount[reg];
  61         return reg;
  62 }
  63
  64 static int
  65 mtrr_file_del(unsigned long base, unsigned long size,
  66               struct file *file, int page)
  67 {
  68         int reg;
  69         unsigned int *fcount = FILE_FCOUNT(file);
  70
  71         if (!page) {
  72                 if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1)))
  73                         return -EINVAL;
  74                 base >>= PAGE_SHIFT;
  75                 size >>= PAGE_SHIFT;
  76         }
  77         reg = mtrr_del_page(-1, base, size);
  78         if (reg < 0)
  79                 return reg;
  80         if (fcount == NULL)
  81                 return reg;
  82         if (fcount[reg] < 1)
  83                 return -EINVAL;
  84         --fcount[reg];
  85         return reg;
  86 }
  87
  88 /* RED-PEN: seq_file can seek now. this is ignored. */
  89 static ssize_t
  90 mtrr_write(struct file *file, const char __user *buf, size_t len, loff_t * ppos)
  91 /*  Format of control line:
  92     "base=%Lx size=%Lx type=%s"     OR:
  93     "disable=%d"
  94 */
  95 {
  96         int i, err;
  97         unsigned long reg;
  98         unsigned long long base, size;
  99         char *ptr;
 100         char line[LINE_SIZE];
 101
 102         if (!capable(CAP_SYS_ADMIN))
 103                 return -EPERM;
 104         /*  Can't seek (pwrite) on this device  */
 105         if (ppos != &file->f_pos)
 106                 return -ESPIPE;
 107         memset(line, 0, LINE_SIZE);
 108         if (len > LINE_SIZE)
 109                 len = LINE_SIZE;
 110         if (copy_from_user(line, buf, len - 1))
 111                 return -EFAULT;
 112         ptr = line + strlen(line) - 1;
 113         if (*ptr == '\n')
 114                 *ptr = '\0';
 115         if (!strncmp(line, "disable=", 8)) {
 116                 reg = simple_strtoul(line + 8, &ptr, 0);
 117                 err = mtrr_del_page(reg, 0, 0);
 118                 if (err < 0)
 119                         return err;
 120                 return len;
 121         }
 122         if (strncmp(line, "base=", 5))
 123                 return -EINVAL;
 124         base = simple_strtoull(line + 5, &ptr, 0);
 125         for (; isspace(*ptr); ++ptr) ;
 126         if (strncmp(ptr, "size=", 5))
 127                 return -EINVAL;
 128         size = simple_strtoull(ptr + 5, &ptr, 0);
 129         if ((base & 0xfff) || (size & 0xfff))
 130                 return -EINVAL;
 131         for (; isspace(*ptr); ++ptr) ;
 132         if (strncmp(ptr, "type=", 5))
 133                 return -EINVAL;
 134         ptr += 5;
 135         for (; isspace(*ptr); ++ptr) ;
 136         for (i = 0; i < MTRR_NUM_TYPES; ++i) {
 137                 if (strcmp(ptr, mtrr_strings[i]))
 138                         continue;
 139                 base >>= PAGE_SHIFT;
 140                 size >>= PAGE_SHIFT;
 141                 err =
 142                     mtrr_add_page((unsigned long) base, (unsigned long) size, i,
 143                                   1);
 144                 if (err < 0)
 145                         return err;
 146                 return len;
 147         }
 148         return -EINVAL;
 149 }
 150
 151 static int
 152 mtrr_ioctl(struct inode *inode, struct file *file,
 153            unsigned int cmd, unsigned long __arg)
 154 {
 155         int err;
 156         mtrr_type type;
 157         struct mtrr_sentry sentry;
 158         struct mtrr_gentry gentry;
 159         void __user *arg = (void __user *) __arg;
 160
 161         switch (cmd) {
 162         default:
 163                 return -ENOIOCTLCMD;
 164         case MTRRIOC_ADD_ENTRY:
 165                 if (!capable(CAP_SYS_ADMIN))
 166                         return -EPERM;
 167                 if (copy_from_user(&sentry, arg, sizeof sentry))
 168                         return -EFAULT;
 169                 err =
 170                     mtrr_file_add(sentry.base, sentry.size, sentry.type, 1,
 171                                   file, 0);
 172                 if (err < 0)
 173                         return err;
 174                 break;
 175         case MTRRIOC_SET_ENTRY:
 176                 if (!capable(CAP_SYS_ADMIN))
 177                         return -EPERM;
 178                 if (copy_from_user(&sentry, arg, sizeof sentry))
 179                         return -EFAULT;
 180                 err = mtrr_add(sentry.base, sentry.size, sentry.type, 0);
 181                 if (err < 0)
 182                         return err;
 183                 break;
 184         case MTRRIOC_DEL_ENTRY:
 185                 if (!capable(CAP_SYS_ADMIN))
 186                         return -EPERM;
 187                 if (copy_from_user(&sentry, arg, sizeof sentry))
 188                         return -EFAULT;
 189                 err = mtrr_file_del(sentry.base, sentry.size, file, 0);
 190                 if (err < 0)
 191                         return err;
 192                 break;
 193         case MTRRIOC_KILL_ENTRY:
 194                 if (!capable(CAP_SYS_ADMIN))
 195                         return -EPERM;
 196                 if (copy_from_user(&sentry, arg, sizeof sentry))
 197                         return -EFAULT;
 198                 err = mtrr_del(-1, sentry.base, sentry.size);
 199                 if (err < 0)
 200                         return err;
 201                 break;
 202         case MTRRIOC_GET_ENTRY:
 203                 if (copy_from_user(&gentry, arg, sizeof gentry))
 204                         return -EFAULT;
 205                 if (gentry.regnum >= num_var_ranges)
 206                         return -EINVAL;
 207                 mtrr_if->get(gentry.regnum, &gentry.base, &gentry.size, &type);
 208
 209                 /* Hide entries that go above 4GB */
 210                 if (gentry.base + gentry.size > 0x100000
 211                     || gentry.size == 0x100000)
 212                         gentry.base = gentry.size = gentry.type = 0;
 213                 else {
 214                         gentry.base <<= PAGE_SHIFT;
 215                         gentry.size <<= PAGE_SHIFT;
 216                         gentry.type = type;
 217                 }
 218
 219                 if (copy_to_user(arg, &gentry, sizeof gentry))
 220                         return -EFAULT;
 221                 break;
 222         case MTRRIOC_ADD_PAGE_ENTRY:
 223                 if (!capable(CAP_SYS_ADMIN))
 224                         return -EPERM;
 225                 if (copy_from_user(&sentry, arg, sizeof sentry))
 226                         return -EFAULT;
 227                 err =
 228                     mtrr_file_add(sentry.base, sentry.size, sentry.type, 1,
 229                                   file, 1);
 230                 if (err < 0)
 231                         return err;
 232                 break;
 233         case MTRRIOC_SET_PAGE_ENTRY:
 234                 if (!capable(CAP_SYS_ADMIN))
 235                         return -EPERM;
 236                 if (copy_from_user(&sentry, arg, sizeof sentry))
 237                         return -EFAULT;
 238                 err = mtrr_add_page(sentry.base, sentry.size, sentry.type, 0);
 239                 if (err < 0)
 240                         return err;
 241                 break;
 242         case MTRRIOC_DEL_PAGE_ENTRY:
 243                 if (!capable(CAP_SYS_ADMIN))
 244                         return -EPERM;
 245                 if (copy_from_user(&sentry, arg, sizeof sentry))
 246                         return -EFAULT;
 247                 err = mtrr_file_del(sentry.base, sentry.size, file, 1);
 248                 if (err < 0)
 249                         return err;
 250                 break;
 251         case MTRRIOC_KILL_PAGE_ENTRY:
 252                 if (!capable(CAP_SYS_ADMIN))
 253                         return -EPERM;
 254                 if (copy_from_user(&sentry, arg, sizeof sentry))
 255                         return -EFAULT;
 256                 err = mtrr_del_page(-1, sentry.base, sentry.size);
 257                 if (err < 0)
 258                         return err;
 259                 break;
 260         case MTRRIOC_GET_PAGE_ENTRY:
 261                 if (copy_from_user(&gentry, arg, sizeof gentry))
 262                         return -EFAULT;
 263                 if (gentry.regnum >= num_var_ranges)
 264                         return -EINVAL;
 265                 mtrr_if->get(gentry.regnum, &gentry.base, &gentry.size, &type);
 266                 gentry.type = type;
 267
 268                 if (copy_to_user(arg, &gentry, sizeof gentry))
 269                         return -EFAULT;
 270                 break;
 271         }
 272         return 0;
 273 }
 274
 275 static int
 276 mtrr_close(struct inode *ino, struct file *file)
 277 {
 278         int i, max;
 279         unsigned int *fcount = FILE_FCOUNT(file);
 280
 281         if (fcount != NULL) {
 282                 max = num_var_ranges;
 283                 for (i = 0; i < max; ++i) {
 284                         while (fcount[i] > 0) {
 285                                 mtrr_del(i, 0, 0);
 286                                 --fcount[i];
 287                         }
 288                 }
 289                 kfree(fcount);
 290                 FILE_FCOUNT(file) = NULL;
 291         }
 292         return single_release(ino, file);
 293 }
 294
 295 static int mtrr_seq_show(struct seq_file *seq, void *offset);
 296
 297 static int mtrr_open(struct inode *inode, struct file *file)
 298 {
 299         if (!mtrr_if)
 300                 return -EIO;
 301         if (!mtrr_if->get)
 302                 return -ENXIO;
 303         return single_open(file, mtrr_seq_show, NULL);
 304 }
 305
 306 static struct file_operations mtrr_fops = {
 307         .owner   = THIS_MODULE,
 308         .open    = mtrr_open,
 309         .read    = seq_read,
 310         .llseek  = seq_lseek,
 311         .write   = mtrr_write,
 312         .ioctl   = mtrr_ioctl,
 313         .release = mtrr_close,
 314 };
 315
 316
 317 static struct proc_dir_entry *proc_root_mtrr;
 318
 319
 320 static int mtrr_seq_show(struct seq_file *seq, void *offset)
 321 {
 322         char factor;
 323         int i, max, len;
 324         mtrr_type type;
 325         unsigned long base;
 326         unsigned int size;
 327
 328         len = 0;
 329         max = num_var_ranges;
 330         for (i = 0; i < max; i++) {
 331                 mtrr_if->get(i, &base, &size, &type);
 332                 if (size == 0)
 333                         usage_table[i] = 0;
 334                 else {
 335                         if (size < (0x100000 >> PAGE_SHIFT)) {
 336                                 /* less than 1MB */
 337                                 factor = 'K';
 338                                 size <<= PAGE_SHIFT - 10;
 339                         } else {
 340                                 factor = 'M';
 341                                 size >>= 20 - PAGE_SHIFT;
 342                         }
 343                         /* RED-PEN: base can be > 32bit */
 344                         len += seq_printf(seq,
 345                                    "reg%02i: base=0x%05lx000 (%4liMB), size=%4i%cB: %s, count=%d\n",
 346                              i, base, base >> (20 - PAGE_SHIFT), size, factor,
 347                              mtrr_attrib_to_str(type), usage_table[i]);
 348                 }
 349         }
 350         return 0;
 351 }
 352
 353 static int __init mtrr_if_init(void)
 354 {
 355         struct cpuinfo_x86 *c = &boot_cpu_data;
 356
 357         if ((!cpu_has(c, X86_FEATURE_MTRR)) &&
 358             (!cpu_has(c, X86_FEATURE_K6_MTRR)) &&
 359             (!cpu_has(c, X86_FEATURE_CYRIX_ARR)) &&
 360             (!cpu_has(c, X86_FEATURE_CENTAUR_MCR)))
 361                 return -ENODEV;
 362
 363         proc_root_mtrr =
 364             create_proc_entry("mtrr", S_IWUSR | S_IRUGO, &proc_root);
 365         if (proc_root_mtrr) {
 366                 proc_root_mtrr->owner = THIS_MODULE;
 367                 proc_root_mtrr->proc_fops = &mtrr_fops;
 368         }
 369         return 0;
 370 }
 371
 372 arch_initcall(mtrr_if_init);
 373 #endif                  /*  CONFIG_PROC_FS  */