if.c 9.8 KB

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