arch/s390/mm/dump_pagetables.c

   1 #include <linux/seq_file.h>
   2 #include <linux/debugfs.h>
   3 #include <linux/sched.h>
   4 #include <linux/mm.h>
   5 #include <asm/sections.h>
   6 #include <asm/pgtable.h>
   7
   8 static unsigned long max_addr;
   9
  10 struct addr_marker {
  11         unsigned long start_address;
  12         const char *name;
  13 };
  14
  15 enum address_markers_idx {
  16         IDENTITY_NR = 0,
  17         KERNEL_START_NR,
  18         KERNEL_END_NR,
  19         VMEMMAP_NR,
  20         VMALLOC_NR,
  21         MODULES_NR,
  22 };
  23
  24 static struct addr_marker address_markers[] = {
  25         [IDENTITY_NR]     = {0, "Identity Mapping"},
  26         [KERNEL_START_NR] = {(unsigned long)&_stext, "Kernel Image Start"},
  27         [KERNEL_END_NR]   = {(unsigned long)&_end, "Kernel Image End"},
  28         [VMEMMAP_NR]      = {0, "vmemmap Area"},
  29         [VMALLOC_NR]      = {0, "vmalloc Area"},
  30         [MODULES_NR]      = {0, "Modules Area"},
  31         { -1, NULL }
  32 };
  33
  34 struct pg_state {
  35         int level;
  36         unsigned int current_prot;
  37         unsigned long start_address;
  38         unsigned long current_address;
  39         const struct addr_marker *marker;
  40 };
  41
  42 static void print_prot(struct seq_file *m, unsigned int pr, int level)
  43 {
  44         static const char * const level_name[] =
  45                 { "ASCE", "PGD", "PUD", "PMD", "PTE" };
  46
  47         seq_printf(m, "%s ", level_name[level]);
  48         if (pr & _PAGE_INVALID) {
  49                 seq_printf(m, "I\n");
  50                 return;
  51         }
  52         seq_puts(m, (pr & _PAGE_PROTECT) ? "RO " : "RW ");
  53         seq_puts(m, (pr & _PAGE_NOEXEC) ? "NX\n" : "X\n");
  54 }
  55
  56 static void note_page(struct seq_file *m, struct pg_state *st,
  57                      unsigned int new_prot, int level)
  58 {
  59         static const char units[] = "KMGTPE";
  60         int width = sizeof(unsigned long) * 2;
  61         const char *unit = units;
  62         unsigned int prot, cur;
  63         unsigned long delta;
  64
  65         /*
  66          * If we have a "break" in the series, we need to flush the state
  67          * that we have now. "break" is either changing perms, levels or
  68          * address space marker.
  69          */
  70         prot = new_prot;
  71         cur = st->current_prot;
  72
  73         if (!st->level) {
  74                 /* First entry */
  75                 st->current_prot = new_prot;
  76                 st->level = level;
  77                 st->marker = address_markers;
  78                 seq_printf(m, "---[ %s ]---\n", st->marker->name);
  79         } else if (prot != cur || level != st->level ||
  80                    st->current_address >= st->marker[1].start_address) {
  81                 /* Print the actual finished series */
  82                 seq_printf(m, "0x%0*lx-0x%0*lx",
  83                            width, st->start_address,
  84                            width, st->current_address);
  85                 delta = (st->current_address - st->start_address) >> 10;
  86                 while (!(delta & 0x3ff) && unit[1]) {
  87                         delta >>= 10;
  88                         unit++;
  89                 }
  90                 seq_printf(m, "%9lu%c ", delta, *unit);
  91                 print_prot(m, st->current_prot, st->level);
  92                 if (st->current_address >= st->marker[1].start_address) {
  93                         st->marker++;
  94                         seq_printf(m, "---[ %s ]---\n", st->marker->name);
  95                 }
  96                 st->start_address = st->current_address;
  97                 st->current_prot = new_prot;
  98                 st->level = level;
  99         }
 100 }
 101
 102 /*
 103  * The actual page table walker functions. In order to keep the
 104  * implementation of print_prot() short, we only check and pass
 105  * _PAGE_INVALID and _PAGE_PROTECT flags to note_page() if a region,
 106  * segment or page table entry is invalid or read-only.
 107  * After all it's just a hint that the current level being walked
 108  * contains an invalid or read-only entry.
 109  */
 110 static void walk_pte_level(struct seq_file *m, struct pg_state *st,
 111                            pmd_t *pmd, unsigned long addr)
 112 {
 113         unsigned int prot;
 114         pte_t *pte;
 115         int i;
 116
 117         for (i = 0; i < PTRS_PER_PTE && addr < max_addr; i++) {
 118                 st->current_address = addr;
 119                 pte = pte_offset_kernel(pmd, addr);
 120                 prot = pte_val(*pte) &
 121                         (_PAGE_PROTECT | _PAGE_INVALID | _PAGE_NOEXEC);
 122                 note_page(m, st, prot, 4);
 123                 addr += PAGE_SIZE;
 124         }
 125 }
 126
 127 static void walk_pmd_level(struct seq_file *m, struct pg_state *st,
 128                            pud_t *pud, unsigned long addr)
 129 {
 130         unsigned int prot;
 131         pmd_t *pmd;
 132         int i;
 133
 134         for (i = 0; i < PTRS_PER_PMD && addr < max_addr; i++) {
 135                 st->current_address = addr;
 136                 pmd = pmd_offset(pud, addr);
 137                 if (!pmd_none(*pmd)) {
 138                         if (pmd_large(*pmd)) {
 139                                 prot = pmd_val(*pmd) &
 140                                         (_SEGMENT_ENTRY_PROTECT |
 141                                          _SEGMENT_ENTRY_NOEXEC);
 142                                 note_page(m, st, prot, 3);
 143                         } else
 144                                 walk_pte_level(m, st, pmd, addr);
 145                 } else
 146                         note_page(m, st, _PAGE_INVALID, 3);
 147                 addr += PMD_SIZE;
 148         }
 149 }
 150
 151 static void walk_pud_level(struct seq_file *m, struct pg_state *st,
 152                            p4d_t *p4d, unsigned long addr)
 153 {
 154         unsigned int prot;
 155         pud_t *pud;
 156         int i;
 157
 158         for (i = 0; i < PTRS_PER_PUD && addr < max_addr; i++) {
 159                 st->current_address = addr;
 160                 pud = pud_offset(p4d, addr);
 161                 if (!pud_none(*pud))
 162                         if (pud_large(*pud)) {
 163                                 prot = pud_val(*pud) &
 164                                         (_REGION_ENTRY_PROTECT |
 165                                          _REGION_ENTRY_NOEXEC);
 166                                 note_page(m, st, prot, 2);
 167                         } else
 168                                 walk_pmd_level(m, st, pud, addr);
 169                 else
 170                         note_page(m, st, _PAGE_INVALID, 2);
 171                 addr += PUD_SIZE;
 172         }
 173 }
 174
 175 static void walk_p4d_level(struct seq_file *m, struct pg_state *st,
 176                            pgd_t *pgd, unsigned long addr)
 177 {
 178         p4d_t *p4d;
 179         int i;
 180
 181         for (i = 0; i < PTRS_PER_P4D && addr < max_addr; i++) {
 182                 st->current_address = addr;
 183                 p4d = p4d_offset(pgd, addr);
 184                 if (!p4d_none(*p4d))
 185                         walk_pud_level(m, st, p4d, addr);
 186                 else
 187                         note_page(m, st, _PAGE_INVALID, 2);
 188                 addr += P4D_SIZE;
 189         }
 190 }
 191
 192 static void walk_pgd_level(struct seq_file *m)
 193 {
 194         unsigned long addr = 0;
 195         struct pg_state st;
 196         pgd_t *pgd;
 197         int i;
 198
 199         memset(&st, 0, sizeof(st));
 200         for (i = 0; i < PTRS_PER_PGD && addr < max_addr; i++) {
 201                 st.current_address = addr;
 202                 pgd = pgd_offset_k(addr);
 203                 if (!pgd_none(*pgd))
 204                         walk_p4d_level(m, &st, pgd, addr);
 205                 else
 206                         note_page(m, &st, _PAGE_INVALID, 1);
 207                 addr += PGDIR_SIZE;
 208                 cond_resched();
 209         }
 210         /* Flush out the last page */
 211         st.current_address = max_addr;
 212         note_page(m, &st, 0, 0);
 213 }
 214
 215 static int ptdump_show(struct seq_file *m, void *v)
 216 {
 217         walk_pgd_level(m);
 218         return 0;
 219 }
 220
 221 static int ptdump_open(struct inode *inode, struct file *filp)
 222 {
 223         return single_open(filp, ptdump_show, NULL);
 224 }
 225
 226 static const struct file_operations ptdump_fops = {
 227         .open           = ptdump_open,
 228         .read           = seq_read,
 229         .llseek         = seq_lseek,
 230         .release        = single_release,
 231 };
 232
 233 static int pt_dump_init(void)
 234 {
 235         /*
 236          * Figure out the maximum virtual address being accessible with the
 237          * kernel ASCE. We need this to keep the page table walker functions
 238          * from accessing non-existent entries.
 239          */
 240         max_addr = (S390_lowcore.kernel_asce & _REGION_ENTRY_TYPE_MASK) >> 2;
 241         max_addr = 1UL << (max_addr * 11 + 31);
 242         address_markers[MODULES_NR].start_address = MODULES_VADDR;
 243         address_markers[VMEMMAP_NR].start_address = (unsigned long) vmemmap;
 244         address_markers[VMALLOC_NR].start_address = VMALLOC_START;
 245         debugfs_create_file("kernel_page_tables", 0400, NULL, NULL, &ptdump_fops);
 246         return 0;
 247 }
 248 device_initcall(pt_dump_init);