blob: 5f91a38d759258819eca0aaba4f9691268e0fc15 [file] [log] [blame]
Heiko Carstensf4eb07c2006-12-08 15:56:07 +01001/*
2 * arch/s390/mm/vmem.c
3 *
4 * Copyright IBM Corp. 2006
5 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
6 */
7
8#include <linux/bootmem.h>
9#include <linux/pfn.h>
10#include <linux/mm.h>
11#include <linux/module.h>
12#include <linux/list.h>
Gerald Schaefer53492b12008-04-30 13:38:46 +020013#include <linux/hugetlb.h>
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010014#include <asm/pgalloc.h>
15#include <asm/pgtable.h>
16#include <asm/setup.h>
17#include <asm/tlbflush.h>
Gerald Schaefer53492b12008-04-30 13:38:46 +020018#include <asm/sections.h>
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010019
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010020static DEFINE_MUTEX(vmem_mutex);
21
22struct memory_segment {
23 struct list_head list;
24 unsigned long start;
25 unsigned long size;
26};
27
28static LIST_HEAD(mem_segs);
29
Heiko Carstens67060d92008-05-30 10:03:27 +020030static void __ref *vmem_alloc_pages(unsigned int order)
31{
32 if (slab_is_available())
33 return (void *)__get_free_pages(GFP_KERNEL, order);
34 return alloc_bootmem_pages((1 << order) * PAGE_SIZE);
35}
36
37static inline pud_t *vmem_pud_alloc(void)
Martin Schwidefsky5a216a22008-02-09 18:24:36 +010038{
39 pud_t *pud = NULL;
40
41#ifdef CONFIG_64BIT
Heiko Carstens67060d92008-05-30 10:03:27 +020042 pud = vmem_alloc_pages(2);
Martin Schwidefsky5a216a22008-02-09 18:24:36 +010043 if (!pud)
44 return NULL;
Heiko Carstens8fc63652008-04-30 13:38:44 +020045 clear_table((unsigned long *) pud, _REGION3_ENTRY_EMPTY, PAGE_SIZE * 4);
Martin Schwidefsky5a216a22008-02-09 18:24:36 +010046#endif
47 return pud;
48}
Martin Schwidefsky190a1d72007-10-22 12:52:48 +020049
Heiko Carstens67060d92008-05-30 10:03:27 +020050static inline pmd_t *vmem_pmd_alloc(void)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010051{
Martin Schwidefsky3610cce2007-10-22 12:52:47 +020052 pmd_t *pmd = NULL;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010053
Martin Schwidefsky3610cce2007-10-22 12:52:47 +020054#ifdef CONFIG_64BIT
Heiko Carstens67060d92008-05-30 10:03:27 +020055 pmd = vmem_alloc_pages(2);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010056 if (!pmd)
57 return NULL;
Heiko Carstens8fc63652008-04-30 13:38:44 +020058 clear_table((unsigned long *) pmd, _SEGMENT_ENTRY_EMPTY, PAGE_SIZE * 4);
Martin Schwidefsky3610cce2007-10-22 12:52:47 +020059#endif
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010060 return pmd;
61}
62
Heiko Carstens2069e972008-05-15 16:52:31 +020063static pte_t __ref *vmem_pte_alloc(void)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010064{
Martin Schwidefsky146e4b32008-02-09 18:24:35 +010065 pte_t *pte;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010066
Martin Schwidefsky146e4b32008-02-09 18:24:35 +010067 if (slab_is_available())
68 pte = (pte_t *) page_table_alloc(&init_mm);
69 else
70 pte = alloc_bootmem(PTRS_PER_PTE * sizeof(pte_t));
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010071 if (!pte)
72 return NULL;
Martin Schwidefsky146e4b32008-02-09 18:24:35 +010073 clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY,
74 PTRS_PER_PTE * sizeof(pte_t));
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010075 return pte;
76}
77
78/*
79 * Add a physical memory range to the 1:1 mapping.
80 */
Heiko Carstens17f34582008-04-30 13:38:47 +020081static int vmem_add_mem(unsigned long start, unsigned long size, int ro)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010082{
83 unsigned long address;
84 pgd_t *pg_dir;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +020085 pud_t *pu_dir;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +010086 pmd_t *pm_dir;
87 pte_t *pt_dir;
88 pte_t pte;
89 int ret = -ENOMEM;
90
91 for (address = start; address < start + size; address += PAGE_SIZE) {
92 pg_dir = pgd_offset_k(address);
93 if (pgd_none(*pg_dir)) {
Martin Schwidefsky190a1d72007-10-22 12:52:48 +020094 pu_dir = vmem_pud_alloc();
95 if (!pu_dir)
96 goto out;
97 pgd_populate_kernel(&init_mm, pg_dir, pu_dir);
98 }
99
100 pu_dir = pud_offset(pg_dir, address);
101 if (pud_none(*pu_dir)) {
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100102 pm_dir = vmem_pmd_alloc();
103 if (!pm_dir)
104 goto out;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200105 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100106 }
107
Gerald Schaefer53492b12008-04-30 13:38:46 +0200108 pte = mk_pte_phys(address, __pgprot(ro ? _PAGE_RO : 0));
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200109 pm_dir = pmd_offset(pu_dir, address);
Gerald Schaefer53492b12008-04-30 13:38:46 +0200110
111#ifdef __s390x__
112 if (MACHINE_HAS_HPAGE && !(address & ~HPAGE_MASK) &&
113 (address + HPAGE_SIZE <= start + size) &&
114 (address >= HPAGE_SIZE)) {
115 pte_val(pte) |= _SEGMENT_ENTRY_LARGE;
116 pmd_val(*pm_dir) = pte_val(pte);
117 address += HPAGE_SIZE - PAGE_SIZE;
118 continue;
119 }
120#endif
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100121 if (pmd_none(*pm_dir)) {
122 pt_dir = vmem_pte_alloc();
123 if (!pt_dir)
124 goto out;
125 pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
126 }
127
128 pt_dir = pte_offset_kernel(pm_dir, address);
Gerald Schaeferc1821c22007-02-05 21:18:17 +0100129 *pt_dir = pte;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100130 }
131 ret = 0;
132out:
133 flush_tlb_kernel_range(start, start + size);
134 return ret;
135}
136
137/*
138 * Remove a physical memory range from the 1:1 mapping.
139 * Currently only invalidates page table entries.
140 */
141static void vmem_remove_range(unsigned long start, unsigned long size)
142{
143 unsigned long address;
144 pgd_t *pg_dir;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200145 pud_t *pu_dir;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100146 pmd_t *pm_dir;
147 pte_t *pt_dir;
148 pte_t pte;
149
150 pte_val(pte) = _PAGE_TYPE_EMPTY;
151 for (address = start; address < start + size; address += PAGE_SIZE) {
152 pg_dir = pgd_offset_k(address);
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200153 pu_dir = pud_offset(pg_dir, address);
154 if (pud_none(*pu_dir))
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100155 continue;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200156 pm_dir = pmd_offset(pu_dir, address);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100157 if (pmd_none(*pm_dir))
158 continue;
Gerald Schaefer53492b12008-04-30 13:38:46 +0200159
160 if (pmd_huge(*pm_dir)) {
161 pmd_clear_kernel(pm_dir);
162 address += HPAGE_SIZE - PAGE_SIZE;
163 continue;
164 }
165
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100166 pt_dir = pte_offset_kernel(pm_dir, address);
Gerald Schaeferc1821c22007-02-05 21:18:17 +0100167 *pt_dir = pte;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100168 }
169 flush_tlb_kernel_range(start, start + size);
170}
171
172/*
173 * Add a backed mem_map array to the virtual mem_map array.
174 */
Heiko Carstens17f34582008-04-30 13:38:47 +0200175int __meminit vmemmap_populate(struct page *start, unsigned long nr, int node)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100176{
177 unsigned long address, start_addr, end_addr;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100178 pgd_t *pg_dir;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200179 pud_t *pu_dir;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100180 pmd_t *pm_dir;
181 pte_t *pt_dir;
182 pte_t pte;
183 int ret = -ENOMEM;
184
Heiko Carstens17f34582008-04-30 13:38:47 +0200185 start_addr = (unsigned long) start;
186 end_addr = (unsigned long) (start + nr);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100187
188 for (address = start_addr; address < end_addr; address += PAGE_SIZE) {
189 pg_dir = pgd_offset_k(address);
190 if (pgd_none(*pg_dir)) {
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200191 pu_dir = vmem_pud_alloc();
192 if (!pu_dir)
193 goto out;
194 pgd_populate_kernel(&init_mm, pg_dir, pu_dir);
195 }
196
197 pu_dir = pud_offset(pg_dir, address);
198 if (pud_none(*pu_dir)) {
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100199 pm_dir = vmem_pmd_alloc();
200 if (!pm_dir)
201 goto out;
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200202 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100203 }
204
Martin Schwidefsky190a1d72007-10-22 12:52:48 +0200205 pm_dir = pmd_offset(pu_dir, address);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100206 if (pmd_none(*pm_dir)) {
207 pt_dir = vmem_pte_alloc();
208 if (!pt_dir)
209 goto out;
210 pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
211 }
212
213 pt_dir = pte_offset_kernel(pm_dir, address);
214 if (pte_none(*pt_dir)) {
215 unsigned long new_page;
216
Heiko Carstens67060d92008-05-30 10:03:27 +0200217 new_page =__pa(vmem_alloc_pages(0));
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100218 if (!new_page)
219 goto out;
220 pte = pfn_pte(new_page >> PAGE_SHIFT, PAGE_KERNEL);
Gerald Schaeferc1821c22007-02-05 21:18:17 +0100221 *pt_dir = pte;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100222 }
223 }
Heiko Carstens67060d92008-05-30 10:03:27 +0200224 memset(start, 0, nr * sizeof(struct page));
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100225 ret = 0;
226out:
227 flush_tlb_kernel_range(start_addr, end_addr);
228 return ret;
229}
230
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100231/*
232 * Add memory segment to the segment list if it doesn't overlap with
233 * an already present segment.
234 */
235static int insert_memory_segment(struct memory_segment *seg)
236{
237 struct memory_segment *tmp;
238
Heiko Carstensee0ddad2008-06-10 10:03:20 +0200239 if (seg->start + seg->size > VMEM_MAX_PHYS ||
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100240 seg->start + seg->size < seg->start)
241 return -ERANGE;
242
243 list_for_each_entry(tmp, &mem_segs, list) {
244 if (seg->start >= tmp->start + tmp->size)
245 continue;
246 if (seg->start + seg->size <= tmp->start)
247 continue;
248 return -ENOSPC;
249 }
250 list_add(&seg->list, &mem_segs);
251 return 0;
252}
253
254/*
255 * Remove memory segment from the segment list.
256 */
257static void remove_memory_segment(struct memory_segment *seg)
258{
259 list_del(&seg->list);
260}
261
262static void __remove_shared_memory(struct memory_segment *seg)
263{
264 remove_memory_segment(seg);
265 vmem_remove_range(seg->start, seg->size);
266}
267
Heiko Carstens17f34582008-04-30 13:38:47 +0200268int vmem_remove_mapping(unsigned long start, unsigned long size)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100269{
270 struct memory_segment *seg;
271 int ret;
272
273 mutex_lock(&vmem_mutex);
274
275 ret = -ENOENT;
276 list_for_each_entry(seg, &mem_segs, list) {
277 if (seg->start == start && seg->size == size)
278 break;
279 }
280
281 if (seg->start != start || seg->size != size)
282 goto out;
283
284 ret = 0;
285 __remove_shared_memory(seg);
286 kfree(seg);
287out:
288 mutex_unlock(&vmem_mutex);
289 return ret;
290}
291
Heiko Carstens17f34582008-04-30 13:38:47 +0200292int vmem_add_mapping(unsigned long start, unsigned long size)
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100293{
294 struct memory_segment *seg;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100295 int ret;
296
297 mutex_lock(&vmem_mutex);
298 ret = -ENOMEM;
299 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
300 if (!seg)
301 goto out;
302 seg->start = start;
303 seg->size = size;
304
305 ret = insert_memory_segment(seg);
306 if (ret)
307 goto out_free;
308
Gerald Schaefer53492b12008-04-30 13:38:46 +0200309 ret = vmem_add_mem(start, size, 0);
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100310 if (ret)
311 goto out_remove;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100312 goto out;
313
314out_remove:
315 __remove_shared_memory(seg);
316out_free:
317 kfree(seg);
318out:
319 mutex_unlock(&vmem_mutex);
320 return ret;
321}
322
323/*
324 * map whole physical memory to virtual memory (identity mapping)
Christian Borntraeger5fd9c6e2008-01-26 14:11:00 +0100325 * we reserve enough space in the vmalloc area for vmemmap to hotplug
326 * additional memory segments.
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100327 */
328void __init vmem_map_init(void)
329{
Gerald Schaefer53492b12008-04-30 13:38:46 +0200330 unsigned long ro_start, ro_end;
331 unsigned long start, end;
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100332 int i;
333
Martin Schwidefsky50aa98b2009-09-11 10:28:57 +0200334 spin_lock_init(&init_mm.context.list_lock);
Martin Schwidefsky146e4b32008-02-09 18:24:35 +0100335 INIT_LIST_HEAD(&init_mm.context.crst_list);
336 INIT_LIST_HEAD(&init_mm.context.pgtable_list);
337 init_mm.context.noexec = 0;
Gerald Schaefer53492b12008-04-30 13:38:46 +0200338 ro_start = ((unsigned long)&_stext) & PAGE_MASK;
339 ro_end = PFN_ALIGN((unsigned long)&_eshared);
340 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
341 start = memory_chunk[i].addr;
342 end = memory_chunk[i].addr + memory_chunk[i].size;
343 if (start >= ro_end || end <= ro_start)
344 vmem_add_mem(start, end - start, 0);
345 else if (start >= ro_start && end <= ro_end)
346 vmem_add_mem(start, end - start, 1);
347 else if (start >= ro_start) {
348 vmem_add_mem(start, ro_end - start, 1);
349 vmem_add_mem(ro_end, end - ro_end, 0);
350 } else if (end < ro_end) {
351 vmem_add_mem(start, ro_start - start, 0);
352 vmem_add_mem(ro_start, end - ro_start, 1);
353 } else {
354 vmem_add_mem(start, ro_start - start, 0);
355 vmem_add_mem(ro_start, ro_end - ro_start, 1);
356 vmem_add_mem(ro_end, end - ro_end, 0);
357 }
358 }
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100359}
360
361/*
362 * Convert memory chunk array to a memory segment list so there is a single
363 * list that contains both r/w memory and shared memory segments.
364 */
365static int __init vmem_convert_memory_chunk(void)
366{
367 struct memory_segment *seg;
368 int i;
369
370 mutex_lock(&vmem_mutex);
Heiko Carstens9f4b0ba2008-01-26 14:11:02 +0100371 for (i = 0; i < MEMORY_CHUNKS; i++) {
Heiko Carstensf4eb07c2006-12-08 15:56:07 +0100372 if (!memory_chunk[i].size)
373 continue;
374 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
375 if (!seg)
376 panic("Out of memory...\n");
377 seg->start = memory_chunk[i].addr;
378 seg->size = memory_chunk[i].size;
379 insert_memory_segment(seg);
380 }
381 mutex_unlock(&vmem_mutex);
382 return 0;
383}
384
385core_initcall(vmem_convert_memory_chunk);