ptdump.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (C) 2019 SiFive
  4. */
  5. #include <linux/efi.h>
  6. #include <linux/init.h>
  7. #include <linux/debugfs.h>
  8. #include <linux/seq_file.h>
  9. #include <linux/ptdump.h>
  10. #include <asm/ptdump.h>
  11. #include <linux/pgtable.h>
  12. #include <asm/kasan.h>
  13. #define pt_dump_seq_printf(m, fmt, args...) \
  14. ({ \
  15. if (m) \
  16. seq_printf(m, fmt, ##args); \
  17. })
  18. #define pt_dump_seq_puts(m, fmt) \
  19. ({ \
  20. if (m) \
  21. seq_printf(m, fmt); \
  22. })
  23. /*
  24. * The page dumper groups page table entries of the same type into a single
  25. * description. It uses pg_state to track the range information while
  26. * iterating over the pte entries. When the continuity is broken it then
  27. * dumps out a description of the range.
  28. */
  29. struct pg_state {
  30. struct ptdump_state ptdump;
  31. struct seq_file *seq;
  32. const struct addr_marker *marker;
  33. unsigned long start_address;
  34. unsigned long start_pa;
  35. unsigned long last_pa;
  36. int level;
  37. u64 current_prot;
  38. bool check_wx;
  39. unsigned long wx_pages;
  40. };
  41. /* Address marker */
  42. struct addr_marker {
  43. unsigned long start_address;
  44. const char *name;
  45. };
  46. /* Private information for debugfs */
  47. struct ptd_mm_info {
  48. struct mm_struct *mm;
  49. const struct addr_marker *markers;
  50. unsigned long base_addr;
  51. unsigned long end;
  52. };
  53. static struct addr_marker address_markers[] = {
  54. #ifdef CONFIG_KASAN
  55. {KASAN_SHADOW_START, "Kasan shadow start"},
  56. {KASAN_SHADOW_END, "Kasan shadow end"},
  57. #endif
  58. {FIXADDR_START, "Fixmap start"},
  59. {FIXADDR_TOP, "Fixmap end"},
  60. {PCI_IO_START, "PCI I/O start"},
  61. {PCI_IO_END, "PCI I/O end"},
  62. #ifdef CONFIG_SPARSEMEM_VMEMMAP
  63. {VMEMMAP_START, "vmemmap start"},
  64. {VMEMMAP_END, "vmemmap end"},
  65. #endif
  66. {VMALLOC_START, "vmalloc() area"},
  67. {VMALLOC_END, "vmalloc() end"},
  68. {PAGE_OFFSET, "Linear mapping"},
  69. {-1, NULL},
  70. };
  71. static struct ptd_mm_info kernel_ptd_info = {
  72. .mm = &init_mm,
  73. .markers = address_markers,
  74. .base_addr = KERN_VIRT_START,
  75. .end = ULONG_MAX,
  76. };
  77. #ifdef CONFIG_EFI
  78. static struct addr_marker efi_addr_markers[] = {
  79. { 0, "UEFI runtime start" },
  80. { SZ_1G, "UEFI runtime end" },
  81. { -1, NULL }
  82. };
  83. static struct ptd_mm_info efi_ptd_info = {
  84. .mm = &efi_mm,
  85. .markers = efi_addr_markers,
  86. .base_addr = 0,
  87. .end = SZ_2G,
  88. };
  89. #endif
  90. /* Page Table Entry */
  91. struct prot_bits {
  92. u64 mask;
  93. u64 val;
  94. const char *set;
  95. const char *clear;
  96. };
  97. static const struct prot_bits pte_bits[] = {
  98. {
  99. .mask = _PAGE_SOFT,
  100. .val = _PAGE_SOFT,
  101. .set = "RSW",
  102. .clear = " ",
  103. }, {
  104. .mask = _PAGE_DIRTY,
  105. .val = _PAGE_DIRTY,
  106. .set = "D",
  107. .clear = ".",
  108. }, {
  109. .mask = _PAGE_ACCESSED,
  110. .val = _PAGE_ACCESSED,
  111. .set = "A",
  112. .clear = ".",
  113. }, {
  114. .mask = _PAGE_GLOBAL,
  115. .val = _PAGE_GLOBAL,
  116. .set = "G",
  117. .clear = ".",
  118. }, {
  119. .mask = _PAGE_USER,
  120. .val = _PAGE_USER,
  121. .set = "U",
  122. .clear = ".",
  123. }, {
  124. .mask = _PAGE_EXEC,
  125. .val = _PAGE_EXEC,
  126. .set = "X",
  127. .clear = ".",
  128. }, {
  129. .mask = _PAGE_WRITE,
  130. .val = _PAGE_WRITE,
  131. .set = "W",
  132. .clear = ".",
  133. }, {
  134. .mask = _PAGE_READ,
  135. .val = _PAGE_READ,
  136. .set = "R",
  137. .clear = ".",
  138. }, {
  139. .mask = _PAGE_PRESENT,
  140. .val = _PAGE_PRESENT,
  141. .set = "V",
  142. .clear = ".",
  143. }
  144. };
  145. /* Page Level */
  146. struct pg_level {
  147. const char *name;
  148. u64 mask;
  149. };
  150. static struct pg_level pg_level[] = {
  151. { /* pgd */
  152. .name = "PGD",
  153. }, { /* p4d */
  154. .name = (CONFIG_PGTABLE_LEVELS > 4) ? "P4D" : "PGD",
  155. }, { /* pud */
  156. .name = (CONFIG_PGTABLE_LEVELS > 3) ? "PUD" : "PGD",
  157. }, { /* pmd */
  158. .name = (CONFIG_PGTABLE_LEVELS > 2) ? "PMD" : "PGD",
  159. }, { /* pte */
  160. .name = "PTE",
  161. },
  162. };
  163. static void dump_prot(struct pg_state *st)
  164. {
  165. unsigned int i;
  166. for (i = 0; i < ARRAY_SIZE(pte_bits); i++) {
  167. const char *s;
  168. if ((st->current_prot & pte_bits[i].mask) == pte_bits[i].val)
  169. s = pte_bits[i].set;
  170. else
  171. s = pte_bits[i].clear;
  172. if (s)
  173. pt_dump_seq_printf(st->seq, " %s", s);
  174. }
  175. }
  176. #ifdef CONFIG_64BIT
  177. #define ADDR_FORMAT "0x%016lx"
  178. #else
  179. #define ADDR_FORMAT "0x%08lx"
  180. #endif
  181. static void dump_addr(struct pg_state *st, unsigned long addr)
  182. {
  183. static const char units[] = "KMGTPE";
  184. const char *unit = units;
  185. unsigned long delta;
  186. pt_dump_seq_printf(st->seq, ADDR_FORMAT "-" ADDR_FORMAT " ",
  187. st->start_address, addr);
  188. pt_dump_seq_printf(st->seq, " " ADDR_FORMAT " ", st->start_pa);
  189. delta = (addr - st->start_address) >> 10;
  190. while (!(delta & 1023) && unit[1]) {
  191. delta >>= 10;
  192. unit++;
  193. }
  194. pt_dump_seq_printf(st->seq, "%9lu%c %s", delta, *unit,
  195. pg_level[st->level].name);
  196. }
  197. static void note_prot_wx(struct pg_state *st, unsigned long addr)
  198. {
  199. if (!st->check_wx)
  200. return;
  201. if ((st->current_prot & (_PAGE_WRITE | _PAGE_EXEC)) !=
  202. (_PAGE_WRITE | _PAGE_EXEC))
  203. return;
  204. WARN_ONCE(1, "riscv/mm: Found insecure W+X mapping at address %p/%pS\n",
  205. (void *)st->start_address, (void *)st->start_address);
  206. st->wx_pages += (addr - st->start_address) / PAGE_SIZE;
  207. }
  208. static void note_page(struct ptdump_state *pt_st, unsigned long addr,
  209. int level, u64 val)
  210. {
  211. struct pg_state *st = container_of(pt_st, struct pg_state, ptdump);
  212. u64 pa = PFN_PHYS(pte_pfn(__pte(val)));
  213. u64 prot = 0;
  214. if (level >= 0)
  215. prot = val & pg_level[level].mask;
  216. if (st->level == -1) {
  217. st->level = level;
  218. st->current_prot = prot;
  219. st->start_address = addr;
  220. st->start_pa = pa;
  221. st->last_pa = pa;
  222. pt_dump_seq_printf(st->seq, "---[ %s ]---\n", st->marker->name);
  223. } else if (prot != st->current_prot ||
  224. level != st->level || addr >= st->marker[1].start_address) {
  225. if (st->current_prot) {
  226. note_prot_wx(st, addr);
  227. dump_addr(st, addr);
  228. dump_prot(st);
  229. pt_dump_seq_puts(st->seq, "\n");
  230. }
  231. while (addr >= st->marker[1].start_address) {
  232. st->marker++;
  233. pt_dump_seq_printf(st->seq, "---[ %s ]---\n",
  234. st->marker->name);
  235. }
  236. st->start_address = addr;
  237. st->start_pa = pa;
  238. st->last_pa = pa;
  239. st->current_prot = prot;
  240. st->level = level;
  241. } else {
  242. st->last_pa = pa;
  243. }
  244. }
  245. static void ptdump_walk(struct seq_file *s, struct ptd_mm_info *pinfo)
  246. {
  247. struct pg_state st = {
  248. .seq = s,
  249. .marker = pinfo->markers,
  250. .level = -1,
  251. .ptdump = {
  252. .note_page = note_page,
  253. .range = (struct ptdump_range[]) {
  254. {pinfo->base_addr, pinfo->end},
  255. {0, 0}
  256. }
  257. }
  258. };
  259. ptdump_walk_pgd(&st.ptdump, pinfo->mm, NULL);
  260. }
  261. void ptdump_check_wx(void)
  262. {
  263. struct pg_state st = {
  264. .seq = NULL,
  265. .marker = (struct addr_marker[]) {
  266. {0, NULL},
  267. {-1, NULL},
  268. },
  269. .level = -1,
  270. .check_wx = true,
  271. .ptdump = {
  272. .note_page = note_page,
  273. .range = (struct ptdump_range[]) {
  274. {KERN_VIRT_START, ULONG_MAX},
  275. {0, 0}
  276. }
  277. }
  278. };
  279. ptdump_walk_pgd(&st.ptdump, &init_mm, NULL);
  280. if (st.wx_pages)
  281. pr_warn("Checked W+X mappings: failed, %lu W+X pages found\n",
  282. st.wx_pages);
  283. else
  284. pr_info("Checked W+X mappings: passed, no W+X pages found\n");
  285. }
  286. static int ptdump_show(struct seq_file *m, void *v)
  287. {
  288. ptdump_walk(m, m->private);
  289. return 0;
  290. }
  291. DEFINE_SHOW_ATTRIBUTE(ptdump);
  292. static int ptdump_init(void)
  293. {
  294. unsigned int i, j;
  295. for (i = 0; i < ARRAY_SIZE(pg_level); i++)
  296. for (j = 0; j < ARRAY_SIZE(pte_bits); j++)
  297. pg_level[i].mask |= pte_bits[j].mask;
  298. debugfs_create_file("kernel_page_tables", 0400, NULL, &kernel_ptd_info,
  299. &ptdump_fops);
  300. #ifdef CONFIG_EFI
  301. if (efi_enabled(EFI_RUNTIME_SERVICES))
  302. debugfs_create_file("efi_page_tables", 0400, NULL, &efi_ptd_info,
  303. &ptdump_fops);
  304. #endif
  305. return 0;
  306. }
  307. device_initcall(ptdump_init);