4 * Copyright IBM Corp. 2006
5 * Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
8 #include <linux/bootmem.h>
11 #include <linux/module.h>
12 #include <linux/list.h>
13 #include <asm/pgalloc.h>
14 #include <asm/pgtable.h>
15 #include <asm/setup.h>
16 #include <asm/tlbflush.h>
18 static DEFINE_MUTEX(vmem_mutex);
20 struct memory_segment {
21 struct list_head list;
26 static LIST_HEAD(mem_segs);
28 void __meminit memmap_init(unsigned long size, int nid, unsigned long zone,
29 unsigned long start_pfn)
31 struct page *start, *end;
32 struct page *map_start, *map_end;
35 start = pfn_to_page(start_pfn);
38 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++) {
39 unsigned long cstart, cend;
41 cstart = PFN_DOWN(memory_chunk[i].addr);
42 cend = cstart + PFN_DOWN(memory_chunk[i].size);
44 map_start = mem_map + cstart;
45 map_end = mem_map + cend;
47 if (map_start < start)
52 map_start -= ((unsigned long) map_start & (PAGE_SIZE - 1))
53 / sizeof(struct page);
54 map_end += ((PFN_ALIGN((unsigned long) map_end)
55 - (unsigned long) map_end)
56 / sizeof(struct page));
58 if (map_start < map_end)
59 memmap_init_zone((unsigned long)(map_end - map_start),
60 nid, zone, page_to_pfn(map_start),
65 static void __ref *vmem_alloc_pages(unsigned int order)
67 if (slab_is_available())
68 return (void *)__get_free_pages(GFP_KERNEL, order);
69 return alloc_bootmem_pages((1 << order) * PAGE_SIZE);
72 static inline pud_t *vmem_pud_alloc(void)
77 pud = vmem_alloc_pages(2);
80 clear_table((unsigned long *) pud, _REGION3_ENTRY_EMPTY, PAGE_SIZE * 4);
85 static inline pmd_t *vmem_pmd_alloc(void)
90 pmd = vmem_alloc_pages(2);
93 clear_table((unsigned long *) pmd, _SEGMENT_ENTRY_EMPTY, PAGE_SIZE * 4);
98 static pte_t __init_refok *vmem_pte_alloc(void)
102 if (slab_is_available())
103 pte = (pte_t *) page_table_alloc(&init_mm);
105 pte = alloc_bootmem(PTRS_PER_PTE * sizeof(pte_t));
108 clear_table((unsigned long *) pte, _PAGE_TYPE_EMPTY,
109 PTRS_PER_PTE * sizeof(pte_t));
114 * Add a physical memory range to the 1:1 mapping.
116 static int vmem_add_range(unsigned long start, unsigned long size)
118 unsigned long address;
126 for (address = start; address < start + size; address += PAGE_SIZE) {
127 pg_dir = pgd_offset_k(address);
128 if (pgd_none(*pg_dir)) {
129 pu_dir = vmem_pud_alloc();
132 pgd_populate_kernel(&init_mm, pg_dir, pu_dir);
135 pu_dir = pud_offset(pg_dir, address);
136 if (pud_none(*pu_dir)) {
137 pm_dir = vmem_pmd_alloc();
140 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
143 pm_dir = pmd_offset(pu_dir, address);
144 if (pmd_none(*pm_dir)) {
145 pt_dir = vmem_pte_alloc();
148 pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
151 pt_dir = pte_offset_kernel(pm_dir, address);
152 pte = pfn_pte(address >> PAGE_SHIFT, PAGE_KERNEL);
157 flush_tlb_kernel_range(start, start + size);
162 * Remove a physical memory range from the 1:1 mapping.
163 * Currently only invalidates page table entries.
165 static void vmem_remove_range(unsigned long start, unsigned long size)
167 unsigned long address;
174 pte_val(pte) = _PAGE_TYPE_EMPTY;
175 for (address = start; address < start + size; address += PAGE_SIZE) {
176 pg_dir = pgd_offset_k(address);
177 pu_dir = pud_offset(pg_dir, address);
178 if (pud_none(*pu_dir))
180 pm_dir = pmd_offset(pu_dir, address);
181 if (pmd_none(*pm_dir))
183 pt_dir = pte_offset_kernel(pm_dir, address);
186 flush_tlb_kernel_range(start, start + size);
190 * Add a backed mem_map array to the virtual mem_map array.
192 static int vmem_add_mem_map(unsigned long start, unsigned long size)
194 unsigned long address, start_addr, end_addr;
195 struct page *map_start, *map_end;
203 map_start = VMEM_MAP + PFN_DOWN(start);
204 map_end = VMEM_MAP + PFN_DOWN(start + size);
206 start_addr = (unsigned long) map_start & PAGE_MASK;
207 end_addr = PFN_ALIGN((unsigned long) map_end);
209 for (address = start_addr; address < end_addr; address += PAGE_SIZE) {
210 pg_dir = pgd_offset_k(address);
211 if (pgd_none(*pg_dir)) {
212 pu_dir = vmem_pud_alloc();
215 pgd_populate_kernel(&init_mm, pg_dir, pu_dir);
218 pu_dir = pud_offset(pg_dir, address);
219 if (pud_none(*pu_dir)) {
220 pm_dir = vmem_pmd_alloc();
223 pud_populate_kernel(&init_mm, pu_dir, pm_dir);
226 pm_dir = pmd_offset(pu_dir, address);
227 if (pmd_none(*pm_dir)) {
228 pt_dir = vmem_pte_alloc();
231 pmd_populate_kernel(&init_mm, pm_dir, pt_dir);
234 pt_dir = pte_offset_kernel(pm_dir, address);
235 if (pte_none(*pt_dir)) {
236 unsigned long new_page;
238 new_page =__pa(vmem_alloc_pages(0));
241 pte = pfn_pte(new_page >> PAGE_SHIFT, PAGE_KERNEL);
247 flush_tlb_kernel_range(start_addr, end_addr);
251 static int vmem_add_mem(unsigned long start, unsigned long size)
255 ret = vmem_add_mem_map(start, size);
258 return vmem_add_range(start, size);
262 * Add memory segment to the segment list if it doesn't overlap with
263 * an already present segment.
265 static int insert_memory_segment(struct memory_segment *seg)
267 struct memory_segment *tmp;
269 if (seg->start + seg->size >= VMEM_MAX_PHYS ||
270 seg->start + seg->size < seg->start)
273 list_for_each_entry(tmp, &mem_segs, list) {
274 if (seg->start >= tmp->start + tmp->size)
276 if (seg->start + seg->size <= tmp->start)
280 list_add(&seg->list, &mem_segs);
285 * Remove memory segment from the segment list.
287 static void remove_memory_segment(struct memory_segment *seg)
289 list_del(&seg->list);
292 static void __remove_shared_memory(struct memory_segment *seg)
294 remove_memory_segment(seg);
295 vmem_remove_range(seg->start, seg->size);
298 int remove_shared_memory(unsigned long start, unsigned long size)
300 struct memory_segment *seg;
303 mutex_lock(&vmem_mutex);
306 list_for_each_entry(seg, &mem_segs, list) {
307 if (seg->start == start && seg->size == size)
311 if (seg->start != start || seg->size != size)
315 __remove_shared_memory(seg);
318 mutex_unlock(&vmem_mutex);
322 int add_shared_memory(unsigned long start, unsigned long size)
324 struct memory_segment *seg;
326 unsigned long pfn, num_pfn, end_pfn;
329 mutex_lock(&vmem_mutex);
331 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
337 ret = insert_memory_segment(seg);
341 ret = vmem_add_mem(start, size);
345 pfn = PFN_DOWN(start);
346 num_pfn = PFN_DOWN(size);
347 end_pfn = pfn + num_pfn;
349 page = pfn_to_page(pfn);
350 memset(page, 0, num_pfn * sizeof(struct page));
352 for (; pfn < end_pfn; pfn++) {
353 page = pfn_to_page(pfn);
354 init_page_count(page);
355 reset_page_mapcount(page);
356 SetPageReserved(page);
357 INIT_LIST_HEAD(&page->lru);
362 __remove_shared_memory(seg);
366 mutex_unlock(&vmem_mutex);
371 * map whole physical memory to virtual memory (identity mapping)
372 * we reserve enough space in the vmalloc area for vmemmap to hotplug
373 * additional memory segments.
375 void __init vmem_map_init(void)
379 INIT_LIST_HEAD(&init_mm.context.crst_list);
380 INIT_LIST_HEAD(&init_mm.context.pgtable_list);
381 init_mm.context.noexec = 0;
382 NODE_DATA(0)->node_mem_map = VMEM_MAP;
383 for (i = 0; i < MEMORY_CHUNKS && memory_chunk[i].size > 0; i++)
384 vmem_add_mem(memory_chunk[i].addr, memory_chunk[i].size);
388 * Convert memory chunk array to a memory segment list so there is a single
389 * list that contains both r/w memory and shared memory segments.
391 static int __init vmem_convert_memory_chunk(void)
393 struct memory_segment *seg;
396 mutex_lock(&vmem_mutex);
397 for (i = 0; i < MEMORY_CHUNKS; i++) {
398 if (!memory_chunk[i].size)
400 seg = kzalloc(sizeof(*seg), GFP_KERNEL);
402 panic("Out of memory...\n");
403 seg->start = memory_chunk[i].addr;
404 seg->size = memory_chunk[i].size;
405 insert_memory_segment(seg);
407 mutex_unlock(&vmem_mutex);
411 core_initcall(vmem_convert_memory_chunk);