Commit | Line | Data |
---|---|---|
a9415644 | 1 | #include <linux/capability.h> |
1da177e4 | 2 | #include <linux/seq_file.h> |
26dc67ed JSR |
3 | #include <linux/uaccess.h> |
4 | #include <linux/proc_fs.h> | |
26dc67ed | 5 | #include <linux/ctype.h> |
e7d2860b | 6 | #include <linux/string.h> |
5a0e3ad6 | 7 | #include <linux/slab.h> |
26dc67ed | 8 | #include <linux/init.h> |
1da177e4 LT |
9 | |
10 | #define LINE_SIZE 80 | |
11 | ||
12 | #include <asm/mtrr.h> | |
26dc67ed | 13 | |
1da177e4 LT |
14 | #include "mtrr.h" |
15 | ||
1da177e4 LT |
16 | #define FILE_FCOUNT(f) (((struct seq_file *)((f)->private_data))->private) |
17 | ||
365bff80 | 18 | static const char *const mtrr_strings[MTRR_NUM_TYPES] = |
1da177e4 | 19 | { |
26dc67ed JSR |
20 | "uncachable", /* 0 */ |
21 | "write-combining", /* 1 */ | |
22 | "?", /* 2 */ | |
23 | "?", /* 3 */ | |
24 | "write-through", /* 4 */ | |
25 | "write-protect", /* 5 */ | |
26 | "write-back", /* 6 */ | |
1da177e4 LT |
27 | }; |
28 | ||
365bff80 | 29 | const char *mtrr_attrib_to_str(int x) |
1da177e4 LT |
30 | { |
31 | return (x <= 6) ? mtrr_strings[x] : "?"; | |
32 | } | |
33 | ||
34 | #ifdef CONFIG_PROC_FS | |
35 | ||
36 | static int | |
37 | mtrr_file_add(unsigned long base, unsigned long size, | |
2d2ee8de | 38 | unsigned int type, bool increment, struct file *file, int page) |
1da177e4 | 39 | { |
26dc67ed | 40 | unsigned int *fcount = FILE_FCOUNT(file); |
1da177e4 | 41 | int reg, max; |
1da177e4 LT |
42 | |
43 | max = num_var_ranges; | |
44 | if (fcount == NULL) { | |
9cfa5b5d | 45 | fcount = kzalloc(max * sizeof *fcount, GFP_KERNEL); |
1da177e4 LT |
46 | if (!fcount) |
47 | return -ENOMEM; | |
1da177e4 LT |
48 | FILE_FCOUNT(file) = fcount; |
49 | } | |
50 | if (!page) { | |
51 | if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) | |
52 | return -EINVAL; | |
53 | base >>= PAGE_SHIFT; | |
54 | size >>= PAGE_SHIFT; | |
55 | } | |
2d2ee8de | 56 | reg = mtrr_add_page(base, size, type, true); |
1da177e4 LT |
57 | if (reg >= 0) |
58 | ++fcount[reg]; | |
59 | return reg; | |
60 | } | |
61 | ||
62 | static int | |
63 | mtrr_file_del(unsigned long base, unsigned long size, | |
64 | struct file *file, int page) | |
65 | { | |
1da177e4 | 66 | unsigned int *fcount = FILE_FCOUNT(file); |
26dc67ed | 67 | int reg; |
1da177e4 LT |
68 | |
69 | if (!page) { | |
70 | if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) | |
71 | return -EINVAL; | |
72 | base >>= PAGE_SHIFT; | |
73 | size >>= PAGE_SHIFT; | |
74 | } | |
75 | reg = mtrr_del_page(-1, base, size); | |
76 | if (reg < 0) | |
77 | return reg; | |
78 | if (fcount == NULL) | |
79 | return reg; | |
80 | if (fcount[reg] < 1) | |
81 | return -EINVAL; | |
82 | --fcount[reg]; | |
83 | return reg; | |
84 | } | |
85 | ||
26dc67ed JSR |
86 | /* |
87 | * seq_file can seek but we ignore it. | |
88 | * | |
89 | * Format of control line: | |
90 | * "base=%Lx size=%Lx type=%s" or "disable=%d" | |
91 | */ | |
1da177e4 LT |
92 | static ssize_t |
93 | mtrr_write(struct file *file, const char __user *buf, size_t len, loff_t * ppos) | |
1da177e4 LT |
94 | { |
95 | int i, err; | |
96 | unsigned long reg; | |
97 | unsigned long long base, size; | |
98 | char *ptr; | |
99 | char line[LINE_SIZE]; | |
11879ba5 | 100 | int length; |
1da177e4 LT |
101 | size_t linelen; |
102 | ||
103 | if (!capable(CAP_SYS_ADMIN)) | |
104 | return -EPERM; | |
26dc67ed | 105 | |
1da177e4 | 106 | memset(line, 0, LINE_SIZE); |
11879ba5 AV |
107 | |
108 | length = len; | |
109 | length--; | |
110 | ||
111 | if (length > LINE_SIZE - 1) | |
112 | length = LINE_SIZE - 1; | |
113 | ||
114 | if (length < 0) | |
115 | return -EINVAL; | |
116 | ||
117 | if (copy_from_user(line, buf, length)) | |
1da177e4 | 118 | return -EFAULT; |
26dc67ed | 119 | |
1da177e4 LT |
120 | linelen = strlen(line); |
121 | ptr = line + linelen - 1; | |
122 | if (linelen && *ptr == '\n') | |
123 | *ptr = '\0'; | |
26dc67ed | 124 | |
1da177e4 LT |
125 | if (!strncmp(line, "disable=", 8)) { |
126 | reg = simple_strtoul(line + 8, &ptr, 0); | |
127 | err = mtrr_del_page(reg, 0, 0); | |
128 | if (err < 0) | |
129 | return err; | |
130 | return len; | |
131 | } | |
26dc67ed | 132 | |
1da177e4 LT |
133 | if (strncmp(line, "base=", 5)) |
134 | return -EINVAL; | |
26dc67ed | 135 | |
1da177e4 | 136 | base = simple_strtoull(line + 5, &ptr, 0); |
e7d2860b | 137 | ptr = skip_spaces(ptr); |
26dc67ed | 138 | |
1da177e4 LT |
139 | if (strncmp(ptr, "size=", 5)) |
140 | return -EINVAL; | |
26dc67ed | 141 | |
1da177e4 LT |
142 | size = simple_strtoull(ptr + 5, &ptr, 0); |
143 | if ((base & 0xfff) || (size & 0xfff)) | |
144 | return -EINVAL; | |
e7d2860b | 145 | ptr = skip_spaces(ptr); |
26dc67ed | 146 | |
1da177e4 LT |
147 | if (strncmp(ptr, "type=", 5)) |
148 | return -EINVAL; | |
e7d2860b | 149 | ptr = skip_spaces(ptr + 5); |
26dc67ed | 150 | |
1da177e4 LT |
151 | for (i = 0; i < MTRR_NUM_TYPES; ++i) { |
152 | if (strcmp(ptr, mtrr_strings[i])) | |
153 | continue; | |
154 | base >>= PAGE_SHIFT; | |
155 | size >>= PAGE_SHIFT; | |
26dc67ed | 156 | err = mtrr_add_page((unsigned long)base, (unsigned long)size, i, true); |
1da177e4 LT |
157 | if (err < 0) |
158 | return err; | |
159 | return len; | |
160 | } | |
161 | return -EINVAL; | |
162 | } | |
163 | ||
c5311781 BG |
164 | static long |
165 | mtrr_ioctl(struct file *file, unsigned int cmd, unsigned long __arg) | |
1da177e4 | 166 | { |
c5311781 | 167 | int err = 0; |
1da177e4 | 168 | mtrr_type type; |
b263b31e | 169 | unsigned long base; |
365bff80 | 170 | unsigned long size; |
1da177e4 LT |
171 | struct mtrr_sentry sentry; |
172 | struct mtrr_gentry gentry; | |
173 | void __user *arg = (void __user *) __arg; | |
174 | ||
c5311781 BG |
175 | switch (cmd) { |
176 | case MTRRIOC_ADD_ENTRY: | |
177 | case MTRRIOC_SET_ENTRY: | |
178 | case MTRRIOC_DEL_ENTRY: | |
179 | case MTRRIOC_KILL_ENTRY: | |
180 | case MTRRIOC_ADD_PAGE_ENTRY: | |
181 | case MTRRIOC_SET_PAGE_ENTRY: | |
182 | case MTRRIOC_DEL_PAGE_ENTRY: | |
183 | case MTRRIOC_KILL_PAGE_ENTRY: | |
184 | if (copy_from_user(&sentry, arg, sizeof sentry)) | |
185 | return -EFAULT; | |
186 | break; | |
187 | case MTRRIOC_GET_ENTRY: | |
188 | case MTRRIOC_GET_PAGE_ENTRY: | |
189 | if (copy_from_user(&gentry, arg, sizeof gentry)) | |
190 | return -EFAULT; | |
191 | break; | |
192 | #ifdef CONFIG_COMPAT | |
193 | case MTRRIOC32_ADD_ENTRY: | |
194 | case MTRRIOC32_SET_ENTRY: | |
195 | case MTRRIOC32_DEL_ENTRY: | |
196 | case MTRRIOC32_KILL_ENTRY: | |
197 | case MTRRIOC32_ADD_PAGE_ENTRY: | |
198 | case MTRRIOC32_SET_PAGE_ENTRY: | |
199 | case MTRRIOC32_DEL_PAGE_ENTRY: | |
200 | case MTRRIOC32_KILL_PAGE_ENTRY: { | |
26dc67ed JSR |
201 | struct mtrr_sentry32 __user *s32; |
202 | ||
203 | s32 = (struct mtrr_sentry32 __user *)__arg; | |
c5311781 BG |
204 | err = get_user(sentry.base, &s32->base); |
205 | err |= get_user(sentry.size, &s32->size); | |
206 | err |= get_user(sentry.type, &s32->type); | |
207 | if (err) | |
208 | return err; | |
209 | break; | |
210 | } | |
211 | case MTRRIOC32_GET_ENTRY: | |
212 | case MTRRIOC32_GET_PAGE_ENTRY: { | |
26dc67ed JSR |
213 | struct mtrr_gentry32 __user *g32; |
214 | ||
215 | g32 = (struct mtrr_gentry32 __user *)__arg; | |
c5311781 BG |
216 | err = get_user(gentry.regnum, &g32->regnum); |
217 | err |= get_user(gentry.base, &g32->base); | |
218 | err |= get_user(gentry.size, &g32->size); | |
219 | err |= get_user(gentry.type, &g32->type); | |
220 | if (err) | |
221 | return err; | |
222 | break; | |
223 | } | |
224 | #endif | |
225 | } | |
226 | ||
1da177e4 LT |
227 | switch (cmd) { |
228 | default: | |
229 | return -ENOTTY; | |
230 | case MTRRIOC_ADD_ENTRY: | |
98838ec9 GP |
231 | #ifdef CONFIG_COMPAT |
232 | case MTRRIOC32_ADD_ENTRY: | |
233 | #endif | |
1da177e4 LT |
234 | if (!capable(CAP_SYS_ADMIN)) |
235 | return -EPERM; | |
1da177e4 | 236 | err = |
2d2ee8de | 237 | mtrr_file_add(sentry.base, sentry.size, sentry.type, true, |
1da177e4 | 238 | file, 0); |
1da177e4 LT |
239 | break; |
240 | case MTRRIOC_SET_ENTRY: | |
98838ec9 GP |
241 | #ifdef CONFIG_COMPAT |
242 | case MTRRIOC32_SET_ENTRY: | |
243 | #endif | |
1da177e4 LT |
244 | if (!capable(CAP_SYS_ADMIN)) |
245 | return -EPERM; | |
2d2ee8de | 246 | err = mtrr_add(sentry.base, sentry.size, sentry.type, false); |
1da177e4 LT |
247 | break; |
248 | case MTRRIOC_DEL_ENTRY: | |
98838ec9 GP |
249 | #ifdef CONFIG_COMPAT |
250 | case MTRRIOC32_DEL_ENTRY: | |
251 | #endif | |
1da177e4 LT |
252 | if (!capable(CAP_SYS_ADMIN)) |
253 | return -EPERM; | |
1da177e4 | 254 | err = mtrr_file_del(sentry.base, sentry.size, file, 0); |
1da177e4 LT |
255 | break; |
256 | case MTRRIOC_KILL_ENTRY: | |
98838ec9 GP |
257 | #ifdef CONFIG_COMPAT |
258 | case MTRRIOC32_KILL_ENTRY: | |
259 | #endif | |
1da177e4 LT |
260 | if (!capable(CAP_SYS_ADMIN)) |
261 | return -EPERM; | |
1da177e4 | 262 | err = mtrr_del(-1, sentry.base, sentry.size); |
1da177e4 LT |
263 | break; |
264 | case MTRRIOC_GET_ENTRY: | |
98838ec9 GP |
265 | #ifdef CONFIG_COMPAT |
266 | case MTRRIOC32_GET_ENTRY: | |
267 | #endif | |
1da177e4 LT |
268 | if (gentry.regnum >= num_var_ranges) |
269 | return -EINVAL; | |
b263b31e | 270 | mtrr_if->get(gentry.regnum, &base, &size, &type); |
1da177e4 LT |
271 | |
272 | /* Hide entries that go above 4GB */ | |
b263b31e | 273 | if (base + size - 1 >= (1UL << (8 * sizeof(gentry.size) - PAGE_SHIFT)) |
365bff80 | 274 | || size >= (1UL << (8 * sizeof(gentry.size) - PAGE_SHIFT))) |
1da177e4 LT |
275 | gentry.base = gentry.size = gentry.type = 0; |
276 | else { | |
b263b31e | 277 | gentry.base = base << PAGE_SHIFT; |
365bff80 | 278 | gentry.size = size << PAGE_SHIFT; |
1da177e4 LT |
279 | gentry.type = type; |
280 | } | |
281 | ||
1da177e4 LT |
282 | break; |
283 | case MTRRIOC_ADD_PAGE_ENTRY: | |
98838ec9 GP |
284 | #ifdef CONFIG_COMPAT |
285 | case MTRRIOC32_ADD_PAGE_ENTRY: | |
286 | #endif | |
1da177e4 LT |
287 | if (!capable(CAP_SYS_ADMIN)) |
288 | return -EPERM; | |
1da177e4 | 289 | err = |
2d2ee8de | 290 | mtrr_file_add(sentry.base, sentry.size, sentry.type, true, |
1da177e4 | 291 | file, 1); |
1da177e4 LT |
292 | break; |
293 | case MTRRIOC_SET_PAGE_ENTRY: | |
98838ec9 GP |
294 | #ifdef CONFIG_COMPAT |
295 | case MTRRIOC32_SET_PAGE_ENTRY: | |
296 | #endif | |
1da177e4 LT |
297 | if (!capable(CAP_SYS_ADMIN)) |
298 | return -EPERM; | |
2d2ee8de PJ |
299 | err = |
300 | mtrr_add_page(sentry.base, sentry.size, sentry.type, false); | |
1da177e4 LT |
301 | break; |
302 | case MTRRIOC_DEL_PAGE_ENTRY: | |
98838ec9 GP |
303 | #ifdef CONFIG_COMPAT |
304 | case MTRRIOC32_DEL_PAGE_ENTRY: | |
305 | #endif | |
1da177e4 LT |
306 | if (!capable(CAP_SYS_ADMIN)) |
307 | return -EPERM; | |
1da177e4 | 308 | err = mtrr_file_del(sentry.base, sentry.size, file, 1); |
1da177e4 LT |
309 | break; |
310 | case MTRRIOC_KILL_PAGE_ENTRY: | |
98838ec9 GP |
311 | #ifdef CONFIG_COMPAT |
312 | case MTRRIOC32_KILL_PAGE_ENTRY: | |
313 | #endif | |
1da177e4 LT |
314 | if (!capable(CAP_SYS_ADMIN)) |
315 | return -EPERM; | |
1da177e4 | 316 | err = mtrr_del_page(-1, sentry.base, sentry.size); |
1da177e4 LT |
317 | break; |
318 | case MTRRIOC_GET_PAGE_ENTRY: | |
98838ec9 GP |
319 | #ifdef CONFIG_COMPAT |
320 | case MTRRIOC32_GET_PAGE_ENTRY: | |
321 | #endif | |
1da177e4 LT |
322 | if (gentry.regnum >= num_var_ranges) |
323 | return -EINVAL; | |
b263b31e | 324 | mtrr_if->get(gentry.regnum, &base, &size, &type); |
365bff80 JB |
325 | /* Hide entries that would overflow */ |
326 | if (size != (__typeof__(gentry.size))size) | |
327 | gentry.base = gentry.size = gentry.type = 0; | |
328 | else { | |
b263b31e | 329 | gentry.base = base; |
365bff80 JB |
330 | gentry.size = size; |
331 | gentry.type = type; | |
332 | } | |
c5311781 BG |
333 | break; |
334 | } | |
1da177e4 | 335 | |
c5311781 BG |
336 | if (err) |
337 | return err; | |
338 | ||
26dc67ed | 339 | switch (cmd) { |
c5311781 BG |
340 | case MTRRIOC_GET_ENTRY: |
341 | case MTRRIOC_GET_PAGE_ENTRY: | |
1da177e4 | 342 | if (copy_to_user(arg, &gentry, sizeof gentry)) |
c5311781 | 343 | err = -EFAULT; |
1da177e4 | 344 | break; |
c5311781 BG |
345 | #ifdef CONFIG_COMPAT |
346 | case MTRRIOC32_GET_ENTRY: | |
347 | case MTRRIOC32_GET_PAGE_ENTRY: { | |
26dc67ed JSR |
348 | struct mtrr_gentry32 __user *g32; |
349 | ||
350 | g32 = (struct mtrr_gentry32 __user *)__arg; | |
c5311781 BG |
351 | err = put_user(gentry.base, &g32->base); |
352 | err |= put_user(gentry.size, &g32->size); | |
353 | err |= put_user(gentry.regnum, &g32->regnum); | |
354 | err |= put_user(gentry.type, &g32->type); | |
355 | break; | |
356 | } | |
357 | #endif | |
1da177e4 | 358 | } |
c5311781 | 359 | return err; |
1da177e4 LT |
360 | } |
361 | ||
26dc67ed | 362 | static int mtrr_close(struct inode *ino, struct file *file) |
1da177e4 | 363 | { |
1da177e4 | 364 | unsigned int *fcount = FILE_FCOUNT(file); |
26dc67ed | 365 | int i, max; |
1da177e4 LT |
366 | |
367 | if (fcount != NULL) { | |
368 | max = num_var_ranges; | |
369 | for (i = 0; i < max; ++i) { | |
370 | while (fcount[i] > 0) { | |
371 | mtrr_del(i, 0, 0); | |
372 | --fcount[i]; | |
373 | } | |
374 | } | |
375 | kfree(fcount); | |
376 | FILE_FCOUNT(file) = NULL; | |
377 | } | |
378 | return single_release(ino, file); | |
379 | } | |
380 | ||
381 | static int mtrr_seq_show(struct seq_file *seq, void *offset); | |
382 | ||
383 | static int mtrr_open(struct inode *inode, struct file *file) | |
384 | { | |
26dc67ed | 385 | if (!mtrr_if) |
1da177e4 | 386 | return -EIO; |
26dc67ed JSR |
387 | if (!mtrr_if->get) |
388 | return -ENXIO; | |
1da177e4 LT |
389 | return single_open(file, mtrr_seq_show, NULL); |
390 | } | |
391 | ||
5dfe4c96 | 392 | static const struct file_operations mtrr_fops = { |
26dc67ed JSR |
393 | .owner = THIS_MODULE, |
394 | .open = mtrr_open, | |
395 | .read = seq_read, | |
396 | .llseek = seq_lseek, | |
397 | .write = mtrr_write, | |
398 | .unlocked_ioctl = mtrr_ioctl, | |
399 | .compat_ioctl = mtrr_ioctl, | |
400 | .release = mtrr_close, | |
1da177e4 LT |
401 | }; |
402 | ||
1da177e4 LT |
403 | static int mtrr_seq_show(struct seq_file *seq, void *offset) |
404 | { | |
405 | char factor; | |
3ac62bc0 | 406 | int i, max; |
1da177e4 | 407 | mtrr_type type; |
365bff80 | 408 | unsigned long base, size; |
1da177e4 | 409 | |
1da177e4 LT |
410 | max = num_var_ranges; |
411 | for (i = 0; i < max; i++) { | |
412 | mtrr_if->get(i, &base, &size, &type); | |
26dc67ed | 413 | if (size == 0) { |
99fc8d42 | 414 | mtrr_usage_table[i] = 0; |
26dc67ed | 415 | continue; |
1da177e4 | 416 | } |
26dc67ed JSR |
417 | if (size < (0x100000 >> PAGE_SHIFT)) { |
418 | /* less than 1MB */ | |
419 | factor = 'K'; | |
420 | size <<= PAGE_SHIFT - 10; | |
421 | } else { | |
422 | factor = 'M'; | |
423 | size >>= 20 - PAGE_SHIFT; | |
424 | } | |
425 | /* Base can be > 32bit */ | |
3ac62bc0 JP |
426 | seq_printf(seq, "reg%02i: base=0x%06lx000 (%5luMB), size=%5lu%cB, count=%d: %s\n", |
427 | i, base, base >> (20 - PAGE_SHIFT), | |
428 | size, factor, | |
429 | mtrr_usage_table[i], mtrr_attrib_to_str(type)); | |
1da177e4 LT |
430 | } |
431 | return 0; | |
432 | } | |
433 | ||
434 | static int __init mtrr_if_init(void) | |
435 | { | |
436 | struct cpuinfo_x86 *c = &boot_cpu_data; | |
437 | ||
438 | if ((!cpu_has(c, X86_FEATURE_MTRR)) && | |
439 | (!cpu_has(c, X86_FEATURE_K6_MTRR)) && | |
440 | (!cpu_has(c, X86_FEATURE_CYRIX_ARR)) && | |
441 | (!cpu_has(c, X86_FEATURE_CENTAUR_MCR))) | |
442 | return -ENODEV; | |
443 | ||
99b76233 | 444 | proc_create("mtrr", S_IWUSR | S_IRUGO, NULL, &mtrr_fops); |
1da177e4 LT |
445 | return 0; |
446 | } | |
1da177e4 LT |
447 | arch_initcall(mtrr_if_init); |
448 | #endif /* CONFIG_PROC_FS */ |