cpa-test.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * self test for change_page_attr.
  4. *
  5. * Clears the a test pte bit on random pages in the direct mapping,
  6. * then reverts and compares page tables forwards and afterwards.
  7. */
  8. #include <linux/memblock.h>
  9. #include <linux/kthread.h>
  10. #include <linux/random.h>
  11. #include <linux/kernel.h>
  12. #include <linux/init.h>
  13. #include <linux/mm.h>
  14. #include <linux/vmalloc.h>
  15. #include <asm/cacheflush.h>
  16. #include <asm/kdebug.h>
  17. /*
  18. * Only print the results of the first pass:
  19. */
  20. static __read_mostly int print = 1;
  21. enum {
  22. NTEST = 3 * 100,
  23. NPAGES = 100,
  24. #ifdef CONFIG_X86_64
  25. LPS = (1 << PMD_SHIFT),
  26. #elif defined(CONFIG_X86_PAE)
  27. LPS = (1 << PMD_SHIFT),
  28. #else
  29. LPS = (1 << 22),
  30. #endif
  31. GPS = (1<<30)
  32. };
  33. #define PAGE_CPA_TEST __pgprot(_PAGE_CPA_TEST)
  34. static int pte_testbit(pte_t pte)
  35. {
  36. return pte_flags(pte) & _PAGE_SOFTW1;
  37. }
  38. struct split_state {
  39. long lpg, gpg, spg, exec;
  40. long min_exec, max_exec;
  41. };
  42. static int print_split(struct split_state *s)
  43. {
  44. long i, expected, missed = 0;
  45. int err = 0;
  46. s->lpg = s->gpg = s->spg = s->exec = 0;
  47. s->min_exec = ~0UL;
  48. s->max_exec = 0;
  49. for (i = 0; i < max_pfn_mapped; ) {
  50. unsigned long addr = (unsigned long)__va(i << PAGE_SHIFT);
  51. unsigned int level;
  52. pte_t *pte;
  53. pte = lookup_address(addr, &level);
  54. if (!pte) {
  55. missed++;
  56. i++;
  57. continue;
  58. }
  59. if (level == PG_LEVEL_1G && sizeof(long) == 8) {
  60. s->gpg++;
  61. i += GPS/PAGE_SIZE;
  62. } else if (level == PG_LEVEL_2M) {
  63. if ((pte_val(*pte) & _PAGE_PRESENT) && !(pte_val(*pte) & _PAGE_PSE)) {
  64. printk(KERN_ERR
  65. "%lx level %d but not PSE %Lx\n",
  66. addr, level, (u64)pte_val(*pte));
  67. err = 1;
  68. }
  69. s->lpg++;
  70. i += LPS/PAGE_SIZE;
  71. } else {
  72. s->spg++;
  73. i++;
  74. }
  75. if (!(pte_val(*pte) & _PAGE_NX)) {
  76. s->exec++;
  77. if (addr < s->min_exec)
  78. s->min_exec = addr;
  79. if (addr > s->max_exec)
  80. s->max_exec = addr;
  81. }
  82. }
  83. if (print) {
  84. printk(KERN_INFO
  85. " 4k %lu large %lu gb %lu x %lu[%lx-%lx] miss %lu\n",
  86. s->spg, s->lpg, s->gpg, s->exec,
  87. s->min_exec != ~0UL ? s->min_exec : 0,
  88. s->max_exec, missed);
  89. }
  90. expected = (s->gpg*GPS + s->lpg*LPS)/PAGE_SIZE + s->spg + missed;
  91. if (expected != i) {
  92. printk(KERN_ERR "CPA max_pfn_mapped %lu but expected %lu\n",
  93. max_pfn_mapped, expected);
  94. return 1;
  95. }
  96. return err;
  97. }
  98. static unsigned long addr[NTEST];
  99. static unsigned int len[NTEST];
  100. static struct page *pages[NPAGES];
  101. static unsigned long addrs[NPAGES];
  102. /* Change the global bit on random pages in the direct mapping */
  103. static int pageattr_test(void)
  104. {
  105. struct split_state sa, sb, sc;
  106. unsigned long *bm;
  107. pte_t *pte, pte0;
  108. int failed = 0;
  109. unsigned int level;
  110. int i, k;
  111. int err;
  112. if (print)
  113. printk(KERN_INFO "CPA self-test:\n");
  114. bm = vzalloc((max_pfn_mapped + 7) / 8);
  115. if (!bm) {
  116. printk(KERN_ERR "CPA Cannot vmalloc bitmap\n");
  117. return -ENOMEM;
  118. }
  119. failed += print_split(&sa);
  120. for (i = 0; i < NTEST; i++) {
  121. unsigned long pfn = prandom_u32_max(max_pfn_mapped);
  122. addr[i] = (unsigned long)__va(pfn << PAGE_SHIFT);
  123. len[i] = prandom_u32_max(NPAGES);
  124. len[i] = min_t(unsigned long, len[i], max_pfn_mapped - pfn - 1);
  125. if (len[i] == 0)
  126. len[i] = 1;
  127. pte = NULL;
  128. pte0 = pfn_pte(0, __pgprot(0)); /* shut gcc up */
  129. for (k = 0; k < len[i]; k++) {
  130. pte = lookup_address(addr[i] + k*PAGE_SIZE, &level);
  131. if (!pte || pgprot_val(pte_pgprot(*pte)) == 0 ||
  132. !(pte_val(*pte) & _PAGE_PRESENT)) {
  133. addr[i] = 0;
  134. break;
  135. }
  136. if (k == 0) {
  137. pte0 = *pte;
  138. } else {
  139. if (pgprot_val(pte_pgprot(*pte)) !=
  140. pgprot_val(pte_pgprot(pte0))) {
  141. len[i] = k;
  142. break;
  143. }
  144. }
  145. if (test_bit(pfn + k, bm)) {
  146. len[i] = k;
  147. break;
  148. }
  149. __set_bit(pfn + k, bm);
  150. addrs[k] = addr[i] + k*PAGE_SIZE;
  151. pages[k] = pfn_to_page(pfn + k);
  152. }
  153. if (!addr[i] || !pte || !k) {
  154. addr[i] = 0;
  155. continue;
  156. }
  157. switch (i % 3) {
  158. case 0:
  159. err = change_page_attr_set(&addr[i], len[i], PAGE_CPA_TEST, 0);
  160. break;
  161. case 1:
  162. err = change_page_attr_set(addrs, len[1], PAGE_CPA_TEST, 1);
  163. break;
  164. case 2:
  165. err = cpa_set_pages_array(pages, len[i], PAGE_CPA_TEST);
  166. break;
  167. }
  168. if (err < 0) {
  169. printk(KERN_ERR "CPA %d failed %d\n", i, err);
  170. failed++;
  171. }
  172. pte = lookup_address(addr[i], &level);
  173. if (!pte || !pte_testbit(*pte) || pte_huge(*pte)) {
  174. printk(KERN_ERR "CPA %lx: bad pte %Lx\n", addr[i],
  175. pte ? (u64)pte_val(*pte) : 0ULL);
  176. failed++;
  177. }
  178. if (level != PG_LEVEL_4K) {
  179. printk(KERN_ERR "CPA %lx: unexpected level %d\n",
  180. addr[i], level);
  181. failed++;
  182. }
  183. }
  184. vfree(bm);
  185. failed += print_split(&sb);
  186. for (i = 0; i < NTEST; i++) {
  187. if (!addr[i])
  188. continue;
  189. pte = lookup_address(addr[i], &level);
  190. if (!pte) {
  191. printk(KERN_ERR "CPA lookup of %lx failed\n", addr[i]);
  192. failed++;
  193. continue;
  194. }
  195. err = change_page_attr_clear(&addr[i], len[i], PAGE_CPA_TEST, 0);
  196. if (err < 0) {
  197. printk(KERN_ERR "CPA reverting failed: %d\n", err);
  198. failed++;
  199. }
  200. pte = lookup_address(addr[i], &level);
  201. if (!pte || pte_testbit(*pte)) {
  202. printk(KERN_ERR "CPA %lx: bad pte after revert %Lx\n",
  203. addr[i], pte ? (u64)pte_val(*pte) : 0ULL);
  204. failed++;
  205. }
  206. }
  207. failed += print_split(&sc);
  208. if (failed) {
  209. WARN(1, KERN_ERR "NOT PASSED. Please report.\n");
  210. return -EINVAL;
  211. } else {
  212. if (print)
  213. printk(KERN_INFO "ok.\n");
  214. }
  215. return 0;
  216. }
  217. static int do_pageattr_test(void *__unused)
  218. {
  219. while (!kthread_should_stop()) {
  220. schedule_timeout_interruptible(HZ*30);
  221. if (pageattr_test() < 0)
  222. break;
  223. if (print)
  224. print--;
  225. }
  226. return 0;
  227. }
  228. static int start_pageattr_test(void)
  229. {
  230. struct task_struct *p;
  231. p = kthread_create(do_pageattr_test, NULL, "pageattr-test");
  232. if (!IS_ERR(p))
  233. wake_up_process(p);
  234. else
  235. WARN_ON(1);
  236. return 0;
  237. }
  238. device_initcall(start_pageattr_test);