1
2
3
4
5
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>
13#include <linux/hugetlb.h>
14#include <asm/pgalloc.h>
15#include <asm/pgtable.h>
16#include <asm/setup.h>
17#include <asm/tlbflush.h>
18#include <asm/sections.h>
19
20static 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
30static 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)
38{
39 pud_t *pud = NULL;
40
41#ifdef CONFIG_64BIT
42 pud = vmem_alloc_pages(2);
43 if (!pud)
44 return NULL;
45 clear_table((unsigned long *) pud, _REGION3_ENTRY_EMPTY, PAGE_SIZE * 4);
46#endif
47 return pud;
48}
49
50static inline pmd_t *vmem_pmd_alloc(void)
51{
52 pmd_t *pmd = NULL;
53
54#ifdef CONFIG_64BIT
55 pmd = vmem_alloc_pages(2);
56 if (!pmd)
57 return NULL;
58 clear_table((unsigned long *) pmd, _SEGMENT_ENTRY_EMPTY, PAGE_SIZE * 4);
59#endif
60 return pmd;
61}
62
63static pte_t __ref *vmem_pte_alloc(void)
64{
65 pte_t *pte;
66
67 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));
71 if (!pte)
72 return NULL;
73 clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY,
74 PTRS_PER_PTE * sizeof(pte_t));
75 return pte;
76}
77
78
79
80
81static int vmem_add_mem(unsigned long start, unsigned long size, int ro)
82{
83 unsigned long address;
84 pgd_t *pg_dir;
85 pud_t *pu_dir;
86 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)) {
94 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)) {
102 pm_dir = vmem_pmd_alloc();
103 if (!pm_dir)
104 goto out;
105 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
106 }
107
108 pte = mk_pte_phys(address, __pgprot(ro ? _PAGE_RO : 0));
109 pm_dir = pmd_offset(pu_dir, address);
110
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
121 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);
129 *pt_dir = pte;
130 }
131 ret = 0;
132out:
133 flush_tlb_kernel_range(start, start + size);
134 return ret;
135}
136
137
138
139
140
141static void vmem_remove_range(unsigned long start, unsigned long size)
142{
143 unsigned long address;
144 pgd_t *pg_dir;
145 pud_t *pu_dir;
146 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);
153 pu_dir = pud_offset(pg_dir, address);
154 if (pud_none(*pu_dir))
155 continue;
156 pm_dir = pmd_offset(pu_dir, address);
157 if (pmd_none(*pm_dir))
158 continue;
159
160 if (pmd_huge(*pm_dir)) {
161 pmd_clear_kernel(pm_dir);
162 address += HPAGE_SIZE - PAGE_SIZE;
163 continue;
164 }
165
166 pt_dir = pte_offset_kernel(pm_dir, address);
167 *pt_dir = pte;
168 }
169 flush_tlb_kernel_range(start, start + size);
170}
171
172
173
174
175int __meminit vmemmap_populate(struct page *start, unsigned long nr, int node)
176{
177 unsigned long address, start_addr, end_addr;
178 pgd_t *pg_dir;
179 pud_t *pu_dir;
180 pmd_t *pm_dir;
181 pte_t *pt_dir;
182 pte_t pte;
183 int ret = -ENOMEM;
184
185 start_addr = (unsigned long) start;
186 end_addr = (unsigned long) (start + nr);
187
188 for (address = start_addr; address < end_addr; address += PAGE_SIZE) {
189 pg_dir = pgd_offset_k(address);
190 if (pgd_none(*pg_dir)) {
191 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)) {
199 pm_dir = vmem_pmd_alloc();
200 if (!pm_dir)
201 goto out;
202 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
203 }
204
205 pm_dir = pmd_offset(pu_dir, address);
206 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
217 new_page =__pa(vmem_alloc_pages(0));
218 if (!new_page)
219 goto out;
220 pte = pfn_pte(new_page >> PAGE_SHIFT, PAGE_KERNEL);
221 *pt_dir = pte;
222 }
223 }
224 memset(start, 0, nr * sizeof(struct page));
225 ret = 0;
226out:
227 flush_tlb_kernel_range(start_addr, end_addr);
228 return ret;
229}
230
231
232
233
234
235static int insert_memory_segment(struct memory_segment *seg)
236{
237 struct memory_segment *tmp;
238
239 if (seg->start + seg->size > VMEM_MAX_PHYS ||
240 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
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
268int vmem_remove_mapping(unsigned long start, unsigned long size)
269{
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
292int vmem_add_mapping(unsigned long start, unsigned long size)
293{
294 struct memory_segment *seg;
295 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
309 ret = vmem_add_mem(start, size, 0);
310 if (ret)
311 goto out_remove;
312 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
325
326
327
328void __init vmem_map_init(void)
329{
330 unsigned long ro_start, ro_end;
331 unsigned long start, end;
332 int i;
333
334 INIT_LIST_HEAD(&init_mm.context.crst_list);
335 INIT_LIST_HEAD(&init_mm.context.pgtable_list);
336 init_mm.context.noexec = 0;
337 ro_start = ((unsigned long)&_stext) & PAGE_MASK;
338 ro_end = PFN_ALIGN((unsigned long)&_eshared);
339 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
340 start = memory_chunk[i].addr;
341 end = memory_chunk[i].addr + memory_chunk[i].size;
342 if (start >= ro_end || end <= ro_start)
343 vmem_add_mem(start, end - start, 0);
344 else if (start >= ro_start && end <= ro_end)
345 vmem_add_mem(start, end - start, 1);
346 else if (start >= ro_start) {
347 vmem_add_mem(start, ro_end - start, 1);
348 vmem_add_mem(ro_end, end - ro_end, 0);
349 } else if (end < ro_end) {
350 vmem_add_mem(start, ro_start - start, 0);
351 vmem_add_mem(ro_start, end - ro_start, 1);
352 } else {
353 vmem_add_mem(start, ro_start - start, 0);
354 vmem_add_mem(ro_start, ro_end - ro_start, 1);
355 vmem_add_mem(ro_end, end - ro_end, 0);
356 }
357 }
358}
359
360
361
362
363
364static int __init vmem_convert_memory_chunk(void)
365{
366 struct memory_segment *seg;
367 int i;
368
369 mutex_lock(&vmem_mutex);
370 for (i = 0; i < MEMORY_CHUNKS; i++) {
371 if (!memory_chunk[i].size)
372 continue;
373 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
374 if (!seg)
375 panic("Out of memory...\n");
376 seg->start = memory_chunk[i].addr;
377 seg->size = memory_chunk[i].size;
378 insert_memory_segment(seg);
379 }
380 mutex_unlock(&vmem_mutex);
381 return 0;
382}
383
384core_initcall(vmem_convert_memory_chunk);
385