]>
git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blob - arch/powerpc/mm/pgtable_32.c
2 * This file contains the routines setting up the linux page tables.
5 * Derived from arch/ppc/mm/init.c:
6 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
8 * Modifications by Paul Mackerras (PowerMac) (paulus@cs.anu.edu.au)
9 * and Cort Dougan (PReP) (cort@cs.nmt.edu)
10 * Copyright (C) 1996 Paul Mackerras
12 * Derived from "arch/i386/mm/init.c"
13 * Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License
17 * as published by the Free Software Foundation; either version
18 * 2 of the License, or (at your option) any later version.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/types.h>
26 #include <linux/vmalloc.h>
27 #include <linux/init.h>
28 #include <linux/highmem.h>
29 #include <linux/memblock.h>
30 #include <linux/slab.h>
32 #include <asm/pgtable.h>
33 #include <asm/pgalloc.h>
34 #include <asm/fixmap.h>
36 #include <asm/setup.h>
37 #include <asm/sections.h>
41 unsigned long ioremap_bot
;
42 EXPORT_SYMBOL(ioremap_bot
); /* aka VMALLOC_END */
44 extern char etext
[], _stext
[], _sinittext
[], _einittext
[];
46 __ref pte_t
*pte_alloc_one_kernel(struct mm_struct
*mm
)
48 if (!slab_is_available())
49 return memblock_alloc(PTE_FRAG_SIZE
, PTE_FRAG_SIZE
);
51 return (pte_t
*)pte_fragment_alloc(mm
, 1);
54 pgtable_t
pte_alloc_one(struct mm_struct
*mm
)
56 return (pgtable_t
)pte_fragment_alloc(mm
, 0);
60 ioremap(phys_addr_t addr
, unsigned long size
)
62 pgprot_t prot
= pgprot_noncached(PAGE_KERNEL
);
64 return __ioremap_caller(addr
, size
, prot
, __builtin_return_address(0));
66 EXPORT_SYMBOL(ioremap
);
69 ioremap_wc(phys_addr_t addr
, unsigned long size
)
71 pgprot_t prot
= pgprot_noncached_wc(PAGE_KERNEL
);
73 return __ioremap_caller(addr
, size
, prot
, __builtin_return_address(0));
75 EXPORT_SYMBOL(ioremap_wc
);
78 ioremap_wt(phys_addr_t addr
, unsigned long size
)
80 pgprot_t prot
= pgprot_cached_wthru(PAGE_KERNEL
);
82 return __ioremap_caller(addr
, size
, prot
, __builtin_return_address(0));
84 EXPORT_SYMBOL(ioremap_wt
);
87 ioremap_coherent(phys_addr_t addr
, unsigned long size
)
89 pgprot_t prot
= pgprot_cached(PAGE_KERNEL
);
91 return __ioremap_caller(addr
, size
, prot
, __builtin_return_address(0));
93 EXPORT_SYMBOL(ioremap_coherent
);
96 ioremap_prot(phys_addr_t addr
, unsigned long size
, unsigned long flags
)
98 pte_t pte
= __pte(flags
);
100 /* writeable implies dirty for kernel addresses */
102 pte
= pte_mkdirty(pte
);
104 /* we don't want to let _PAGE_USER and _PAGE_EXEC leak out */
105 pte
= pte_exprotect(pte
);
106 pte
= pte_mkprivileged(pte
);
108 return __ioremap_caller(addr
, size
, pte_pgprot(pte
), __builtin_return_address(0));
110 EXPORT_SYMBOL(ioremap_prot
);
113 __ioremap(phys_addr_t addr
, unsigned long size
, unsigned long flags
)
115 return __ioremap_caller(addr
, size
, __pgprot(flags
), __builtin_return_address(0));
119 __ioremap_caller(phys_addr_t addr
, unsigned long size
, pgprot_t prot
, void *caller
)
126 * Choose an address to map it to.
127 * Once the vmalloc system is running, we use it.
128 * Before then, we use space going down from IOREMAP_TOP
129 * (ioremap_bot records where we're up to).
131 p
= addr
& PAGE_MASK
;
132 size
= PAGE_ALIGN(addr
+ size
) - p
;
135 * If the address lies within the first 16 MB, assume it's in ISA
138 if (p
< 16*1024*1024)
141 #ifndef CONFIG_CRASH_DUMP
143 * Don't allow anybody to remap normal RAM that we're using.
144 * mem_init() sets high_memory so only do the check after that.
146 if (slab_is_available() && p
<= virt_to_phys(high_memory
- 1) &&
147 page_is_ram(__phys_to_pfn(p
))) {
148 printk("__ioremap(): phys addr 0x%llx is RAM lr %ps\n",
149 (unsigned long long)p
, __builtin_return_address(0));
158 * Is it already mapped? Perhaps overlapped by a previous
161 v
= p_block_mapped(p
);
165 if (slab_is_available()) {
166 struct vm_struct
*area
;
167 area
= get_vm_area_caller(size
, VM_IOREMAP
, caller
);
171 v
= (unsigned long) area
->addr
;
173 v
= (ioremap_bot
-= size
);
177 * Should check if it is a candidate for a BAT mapping
181 for (i
= 0; i
< size
&& err
== 0; i
+= PAGE_SIZE
)
182 err
= map_kernel_page(v
+ i
, p
+ i
, prot
);
184 if (slab_is_available())
190 return (void __iomem
*) (v
+ ((unsigned long)addr
& ~PAGE_MASK
));
192 EXPORT_SYMBOL(__ioremap
);
194 void iounmap(volatile void __iomem
*addr
)
197 * If mapped by BATs then there is nothing to do.
198 * Calling vfree() generates a benign warning.
200 if (v_block_mapped((unsigned long)addr
))
203 if (addr
> high_memory
&& (unsigned long) addr
< ioremap_bot
)
204 vunmap((void *) (PAGE_MASK
& (unsigned long)addr
));
206 EXPORT_SYMBOL(iounmap
);
208 int map_kernel_page(unsigned long va
, phys_addr_t pa
, pgprot_t prot
)
214 /* Use upper 10 bits of VA to index the first level map */
215 pd
= pmd_offset(pud_offset(pgd_offset_k(va
), va
), va
);
216 /* Use middle 10 bits of VA to index the second-level map */
217 pg
= pte_alloc_kernel(pd
, va
);
220 /* The PTE should never be already set nor present in the
223 BUG_ON((pte_present(*pg
) | pte_hashpte(*pg
)) && pgprot_val(prot
));
224 set_pte_at(&init_mm
, va
, pg
, pfn_pte(pa
>> PAGE_SHIFT
, prot
));
231 * Map in a chunk of physical memory starting at start.
233 static void __init
__mapin_ram_chunk(unsigned long offset
, unsigned long top
)
241 p
= memstart_addr
+ s
;
242 for (; s
< top
; s
+= PAGE_SIZE
) {
243 ktext
= ((char *)v
>= _stext
&& (char *)v
< etext
) ||
244 ((char *)v
>= _sinittext
&& (char *)v
< _einittext
);
245 map_kernel_page(v
, p
, ktext
? PAGE_KERNEL_TEXT
: PAGE_KERNEL
);
246 #ifdef CONFIG_PPC_BOOK3S_32
248 hash_preload(&init_mm
, v
, false, 0x300);
255 void __init
mapin_ram(void)
257 unsigned long s
, top
;
261 s
= mmu_mapin_ram(top
);
262 __mapin_ram_chunk(s
, top
);
264 if (!wii_hole_size
) {
265 s
= mmu_mapin_ram(total_lowmem
);
266 __mapin_ram_chunk(s
, total_lowmem
);
268 top
= wii_hole_start
;
269 s
= mmu_mapin_ram(top
);
270 __mapin_ram_chunk(s
, top
);
272 top
= memblock_end_of_DRAM();
273 s
= wii_mmu_mapin_mem2(top
);
274 __mapin_ram_chunk(s
, top
);
279 /* Scan the real Linux page tables and return a PTE pointer for
280 * a virtual address in a context.
281 * Returns true (1) if PTE was found, zero otherwise. The pointer to
282 * the PTE pointer is unmodified if PTE is not found.
285 get_pteptr(struct mm_struct
*mm
, unsigned long addr
, pte_t
**ptep
, pmd_t
**pmdp
)
293 pgd
= pgd_offset(mm
, addr
& PAGE_MASK
);
295 pud
= pud_offset(pgd
, addr
& PAGE_MASK
);
296 if (pud
&& pud_present(*pud
)) {
297 pmd
= pmd_offset(pud
, addr
& PAGE_MASK
);
298 if (pmd_present(*pmd
)) {
299 pte
= pte_offset_map(pmd
, addr
& PAGE_MASK
);
305 /* XXX caller needs to do pte_unmap, yuck */
313 static int __change_page_attr_noflush(struct page
*page
, pgprot_t prot
)
317 unsigned long address
;
319 BUG_ON(PageHighMem(page
));
320 address
= (unsigned long)page_address(page
);
322 if (v_block_mapped(address
))
324 if (!get_pteptr(&init_mm
, address
, &kpte
, &kpmd
))
326 __set_pte_at(&init_mm
, address
, kpte
, mk_pte(page
, prot
), 0);
333 * Change the page attributes of an page in the linear mapping.
335 * THIS DOES NOTHING WITH BAT MAPPINGS, DEBUG USE ONLY
337 static int change_page_attr(struct page
*page
, int numpages
, pgprot_t prot
)
341 struct page
*start
= page
;
343 local_irq_save(flags
);
344 for (i
= 0; i
< numpages
; i
++, page
++) {
345 err
= __change_page_attr_noflush(page
, prot
);
350 local_irq_restore(flags
);
351 flush_tlb_kernel_range((unsigned long)page_address(start
),
352 (unsigned long)page_address(page
));
356 void mark_initmem_nx(void)
358 struct page
*page
= virt_to_page(_sinittext
);
359 unsigned long numpages
= PFN_UP((unsigned long)_einittext
) -
360 PFN_DOWN((unsigned long)_sinittext
);
362 change_page_attr(page
, numpages
, PAGE_KERNEL
);
365 #ifdef CONFIG_STRICT_KERNEL_RWX
366 void mark_rodata_ro(void)
369 unsigned long numpages
;
371 page
= virt_to_page(_stext
);
372 numpages
= PFN_UP((unsigned long)_etext
) -
373 PFN_DOWN((unsigned long)_stext
);
375 change_page_attr(page
, numpages
, PAGE_KERNEL_ROX
);
377 * mark .rodata as read only. Use __init_begin rather than __end_rodata
378 * to cover NOTES and EXCEPTION_TABLE.
380 page
= virt_to_page(__start_rodata
);
381 numpages
= PFN_UP((unsigned long)__init_begin
) -
382 PFN_DOWN((unsigned long)__start_rodata
);
384 change_page_attr(page
, numpages
, PAGE_KERNEL_RO
);
388 #ifdef CONFIG_DEBUG_PAGEALLOC
389 void __kernel_map_pages(struct page
*page
, int numpages
, int enable
)
391 if (PageHighMem(page
))
394 change_page_attr(page
, numpages
, enable
? PAGE_KERNEL
: __pgprot(0));
396 #endif /* CONFIG_DEBUG_PAGEALLOC */