~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/mm/dump_pagetables.c

Version: ~ [ linux-5.3-rc4 ] ~ [ linux-5.2.8 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.66 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.138 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.71 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp