Merge branch 'srp' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / 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         size_t linelen;
102
103         if (!capable(CAP_SYS_ADMIN))
104                 return -EPERM;
105         if (!len)
106                 return -EINVAL;
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         linelen = strlen(line);
113         ptr = line + linelen - 1;
114         if (linelen && *ptr == '\n')
115                 *ptr = '\0';
116         if (!strncmp(line, "disable=", 8)) {
117                 reg = simple_strtoul(line + 8, &ptr, 0);
118                 err = mtrr_del_page(reg, 0, 0);
119                 if (err < 0)
120                         return err;
121                 return len;
122         }
123         if (strncmp(line, "base=", 5))
124                 return -EINVAL;
125         base = simple_strtoull(line + 5, &ptr, 0);
126         for (; isspace(*ptr); ++ptr) ;
127         if (strncmp(ptr, "size=", 5))
128                 return -EINVAL;
129         size = simple_strtoull(ptr + 5, &ptr, 0);
130         if ((base & 0xfff) || (size & 0xfff))
131                 return -EINVAL;
132         for (; isspace(*ptr); ++ptr) ;
133         if (strncmp(ptr, "type=", 5))
134                 return -EINVAL;
135         ptr += 5;
136         for (; isspace(*ptr); ++ptr) ;
137         for (i = 0; i < MTRR_NUM_TYPES; ++i) {
138                 if (strcmp(ptr, mtrr_strings[i]))
139                         continue;
140                 base >>= PAGE_SHIFT;
141                 size >>= PAGE_SHIFT;
142                 err =
143                     mtrr_add_page((unsigned long) base, (unsigned long) size, i,
144                                   1);
145                 if (err < 0)
146                         return err;
147                 return len;
148         }
149         return -EINVAL;
150 }
151
152 static long
153 mtrr_ioctl(struct file *file, unsigned int cmd, unsigned long __arg)
154 {
155         int err = 0;
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         case MTRRIOC_ADD_ENTRY:
163         case MTRRIOC_SET_ENTRY:
164         case MTRRIOC_DEL_ENTRY:
165         case MTRRIOC_KILL_ENTRY:
166         case MTRRIOC_ADD_PAGE_ENTRY:
167         case MTRRIOC_SET_PAGE_ENTRY:
168         case MTRRIOC_DEL_PAGE_ENTRY:
169         case MTRRIOC_KILL_PAGE_ENTRY:
170                 if (copy_from_user(&sentry, arg, sizeof sentry))
171                         return -EFAULT;
172                 break;
173         case MTRRIOC_GET_ENTRY:
174         case MTRRIOC_GET_PAGE_ENTRY:
175                 if (copy_from_user(&gentry, arg, sizeof gentry))
176                         return -EFAULT;
177                 break;
178 #ifdef CONFIG_COMPAT
179         case MTRRIOC32_ADD_ENTRY:
180         case MTRRIOC32_SET_ENTRY:
181         case MTRRIOC32_DEL_ENTRY:
182         case MTRRIOC32_KILL_ENTRY:
183         case MTRRIOC32_ADD_PAGE_ENTRY:
184         case MTRRIOC32_SET_PAGE_ENTRY:
185         case MTRRIOC32_DEL_PAGE_ENTRY:
186         case MTRRIOC32_KILL_PAGE_ENTRY: {
187                 struct mtrr_sentry32 __user *s32 = (struct mtrr_sentry32 __user *)__arg;
188                 err = get_user(sentry.base, &s32->base);
189                 err |= get_user(sentry.size, &s32->size);
190                 err |= get_user(sentry.type, &s32->type);
191                 if (err)
192                         return err;
193                 break;
194         }
195         case MTRRIOC32_GET_ENTRY:
196         case MTRRIOC32_GET_PAGE_ENTRY: {
197                 struct mtrr_gentry32 __user *g32 = (struct mtrr_gentry32 __user *)__arg;
198                 err = get_user(gentry.regnum, &g32->regnum);
199                 err |= get_user(gentry.base, &g32->base);
200                 err |= get_user(gentry.size, &g32->size);
201                 err |= get_user(gentry.type, &g32->type);
202                 if (err)
203                         return err;
204                 break;
205         }
206 #endif
207         }
208
209         switch (cmd) {
210         default:
211                 return -ENOTTY;
212         case MTRRIOC_ADD_ENTRY:
213                 if (!capable(CAP_SYS_ADMIN))
214                         return -EPERM;
215                 err =
216                     mtrr_file_add(sentry.base, sentry.size, sentry.type, 1,
217                                   file, 0);
218                 break;
219         case MTRRIOC_SET_ENTRY:
220                 if (!capable(CAP_SYS_ADMIN))
221                         return -EPERM;
222                 err = mtrr_add(sentry.base, sentry.size, sentry.type, 0);
223                 break;
224         case MTRRIOC_DEL_ENTRY:
225                 if (!capable(CAP_SYS_ADMIN))
226                         return -EPERM;
227                 err = mtrr_file_del(sentry.base, sentry.size, file, 0);
228                 break;
229         case MTRRIOC_KILL_ENTRY:
230                 if (!capable(CAP_SYS_ADMIN))
231                         return -EPERM;
232                 err = mtrr_del(-1, sentry.base, sentry.size);
233                 break;
234         case MTRRIOC_GET_ENTRY:
235                 if (gentry.regnum >= num_var_ranges)
236                         return -EINVAL;
237                 mtrr_if->get(gentry.regnum, &gentry.base, &gentry.size, &type);
238
239                 /* Hide entries that go above 4GB */
240                 if (gentry.base + gentry.size > 0x100000
241                     || gentry.size == 0x100000)
242                         gentry.base = gentry.size = gentry.type = 0;
243                 else {
244                         gentry.base <<= PAGE_SHIFT;
245                         gentry.size <<= PAGE_SHIFT;
246                         gentry.type = type;
247                 }
248
249                 break;
250         case MTRRIOC_ADD_PAGE_ENTRY:
251                 if (!capable(CAP_SYS_ADMIN))
252                         return -EPERM;
253                 err =
254                     mtrr_file_add(sentry.base, sentry.size, sentry.type, 1,
255                                   file, 1);
256                 break;
257         case MTRRIOC_SET_PAGE_ENTRY:
258                 if (!capable(CAP_SYS_ADMIN))
259                         return -EPERM;
260                 err = mtrr_add_page(sentry.base, sentry.size, sentry.type, 0);
261                 break;
262         case MTRRIOC_DEL_PAGE_ENTRY:
263                 if (!capable(CAP_SYS_ADMIN))
264                         return -EPERM;
265                 err = mtrr_file_del(sentry.base, sentry.size, file, 1);
266                 break;
267         case MTRRIOC_KILL_PAGE_ENTRY:
268                 if (!capable(CAP_SYS_ADMIN))
269                         return -EPERM;
270                 err = mtrr_del_page(-1, sentry.base, sentry.size);
271                 break;
272         case MTRRIOC_GET_PAGE_ENTRY:
273                 if (gentry.regnum >= num_var_ranges)
274                         return -EINVAL;
275                 mtrr_if->get(gentry.regnum, &gentry.base, &gentry.size, &type);
276                 gentry.type = type;
277                 break;
278         }
279
280         if (err)
281                 return err;
282
283         switch(cmd) {
284         case MTRRIOC_GET_ENTRY:
285         case MTRRIOC_GET_PAGE_ENTRY:
286                 if (copy_to_user(arg, &gentry, sizeof gentry))
287                         err = -EFAULT;
288                 break;
289 #ifdef CONFIG_COMPAT
290         case MTRRIOC32_GET_ENTRY:
291         case MTRRIOC32_GET_PAGE_ENTRY: {
292                 struct mtrr_gentry32 __user *g32 = (struct mtrr_gentry32 __user *)__arg;
293                 err = put_user(gentry.base, &g32->base);
294                 err |= put_user(gentry.size, &g32->size);
295                 err |= put_user(gentry.regnum, &g32->regnum);
296                 err |= put_user(gentry.type, &g32->type);
297                 break;
298         }
299 #endif
300         }
301         return err;
302 }
303
304 static int
305 mtrr_close(struct inode *ino, struct file *file)
306 {
307         int i, max;
308         unsigned int *fcount = FILE_FCOUNT(file);
309
310         if (fcount != NULL) {
311                 max = num_var_ranges;
312                 for (i = 0; i < max; ++i) {
313                         while (fcount[i] > 0) {
314                                 mtrr_del(i, 0, 0);
315                                 --fcount[i];
316                         }
317                 }
318                 kfree(fcount);
319                 FILE_FCOUNT(file) = NULL;
320         }
321         return single_release(ino, file);
322 }
323
324 static int mtrr_seq_show(struct seq_file *seq, void *offset);
325
326 static int mtrr_open(struct inode *inode, struct file *file)
327 {
328         if (!mtrr_if) 
329                 return -EIO;
330         if (!mtrr_if->get) 
331                 return -ENXIO; 
332         return single_open(file, mtrr_seq_show, NULL);
333 }
334
335 static struct file_operations mtrr_fops = {
336         .owner   = THIS_MODULE,
337         .open    = mtrr_open, 
338         .read    = seq_read,
339         .llseek  = seq_lseek,
340         .write   = mtrr_write,
341         .unlocked_ioctl = mtrr_ioctl,
342         .compat_ioctl = mtrr_ioctl,
343         .release = mtrr_close,
344 };
345
346
347 static struct proc_dir_entry *proc_root_mtrr;
348
349
350 static int mtrr_seq_show(struct seq_file *seq, void *offset)
351 {
352         char factor;
353         int i, max, len;
354         mtrr_type type;
355         unsigned long base;
356         unsigned int size;
357
358         len = 0;
359         max = num_var_ranges;
360         for (i = 0; i < max; i++) {
361                 mtrr_if->get(i, &base, &size, &type);
362                 if (size == 0)
363                         usage_table[i] = 0;
364                 else {
365                         if (size < (0x100000 >> PAGE_SHIFT)) {
366                                 /* less than 1MB */
367                                 factor = 'K';
368                                 size <<= PAGE_SHIFT - 10;
369                         } else {
370                                 factor = 'M';
371                                 size >>= 20 - PAGE_SHIFT;
372                         }
373                         /* RED-PEN: base can be > 32bit */ 
374                         len += seq_printf(seq, 
375                                    "reg%02i: base=0x%05lx000 (%4liMB), size=%4i%cB: %s, count=%d\n",
376                              i, base, base >> (20 - PAGE_SHIFT), size, factor,
377                              mtrr_attrib_to_str(type), usage_table[i]);
378                 }
379         }
380         return 0;
381 }
382
383 static int __init mtrr_if_init(void)
384 {
385         struct cpuinfo_x86 *c = &boot_cpu_data;
386
387         if ((!cpu_has(c, X86_FEATURE_MTRR)) &&
388             (!cpu_has(c, X86_FEATURE_K6_MTRR)) &&
389             (!cpu_has(c, X86_FEATURE_CYRIX_ARR)) &&
390             (!cpu_has(c, X86_FEATURE_CENTAUR_MCR)))
391                 return -ENODEV;
392
393         proc_root_mtrr =
394             create_proc_entry("mtrr", S_IWUSR | S_IRUGO, &proc_root);
395         if (proc_root_mtrr) {
396                 proc_root_mtrr->owner = THIS_MODULE;
397                 proc_root_mtrr->proc_fops = &mtrr_fops;
398         }
399         return 0;
400 }
401
402 arch_initcall(mtrr_if_init);
403 #endif                  /*  CONFIG_PROC_FS  */