1 // SPDX-License-Identifier: GPL-2.0
3 * Initialize MMU support.
5 * Copyright (C) 1998-2003 Hewlett-Packard Co
6 * David Mosberger-Tang <davidm@hpl.hp.com>
8 #include <linux/kernel.h>
9 #include <linux/init.h>
11 #include <linux/dma-noncoherent.h>
12 #include <linux/efi.h>
13 #include <linux/elf.h>
14 #include <linux/memblock.h>
16 #include <linux/sched/signal.h>
17 #include <linux/mmzone.h>
18 #include <linux/module.h>
19 #include <linux/personality.h>
20 #include <linux/reboot.h>
21 #include <linux/slab.h>
22 #include <linux/swap.h>
23 #include <linux/proc_fs.h>
24 #include <linux/bitops.h>
25 #include <linux/kexec.h>
29 #include <asm/machvec.h>
31 #include <asm/patch.h>
32 #include <asm/pgalloc.h>
34 #include <asm/sections.h>
36 #include <linux/uaccess.h>
37 #include <asm/unistd.h>
40 extern void ia64_tlb_init (void);
42 unsigned long MAX_DMA_ADDRESS
= PAGE_OFFSET
+ 0x100000000UL
;
44 #ifdef CONFIG_VIRTUAL_MEM_MAP
45 unsigned long VMALLOC_END
= VMALLOC_END_INIT
;
46 EXPORT_SYMBOL(VMALLOC_END
);
47 struct page
*vmem_map
;
48 EXPORT_SYMBOL(vmem_map
);
51 struct page
*zero_page_memmap_ptr
; /* map entry for zero page */
52 EXPORT_SYMBOL(zero_page_memmap_ptr
);
55 __ia64_sync_icache_dcache (pte_t pte
)
61 addr
= (unsigned long) page_address(page
);
63 if (test_bit(PG_arch_1
, &page
->flags
))
64 return; /* i-cache is already coherent with d-cache */
66 flush_icache_range(addr
, addr
+ (PAGE_SIZE
<< compound_order(page
)));
67 set_bit(PG_arch_1
, &page
->flags
); /* mark page as clean */
72 * Since DMA is i-cache coherent, any (complete) pages that were written via
73 * DMA can be marked as "clean" so that lazy_mmu_prot_update() doesn't have to
74 * flush them when they get mapped into an executable vm-area.
76 void arch_sync_dma_for_cpu(struct device
*dev
, phys_addr_t paddr
,
77 size_t size
, enum dma_data_direction dir
)
79 unsigned long pfn
= PHYS_PFN(paddr
);
82 set_bit(PG_arch_1
, &pfn_to_page(pfn
)->flags
);
83 } while (++pfn
<= PHYS_PFN(paddr
+ size
- 1));
88 ia64_set_rbs_bot (void)
90 unsigned long stack_size
= rlimit_max(RLIMIT_STACK
) & -16;
92 if (stack_size
> MAX_USER_STACK_SIZE
)
93 stack_size
= MAX_USER_STACK_SIZE
;
94 current
->thread
.rbs_bot
= PAGE_ALIGN(current
->mm
->start_stack
- stack_size
);
98 * This performs some platform-dependent address space initialization.
99 * On IA-64, we want to setup the VM area for the register backing
100 * store (which grows upwards) and install the gateway page which is
101 * used for signal trampolines, etc.
104 ia64_init_addr_space (void)
106 struct vm_area_struct
*vma
;
111 * If we're out of memory and kmem_cache_alloc() returns NULL, we simply ignore
112 * the problem. When the process attempts to write to the register backing store
113 * for the first time, it will get a SEGFAULT in this case.
115 vma
= vm_area_alloc(current
->mm
);
117 vma_set_anonymous(vma
);
118 vma
->vm_start
= current
->thread
.rbs_bot
& PAGE_MASK
;
119 vma
->vm_end
= vma
->vm_start
+ PAGE_SIZE
;
120 vma
->vm_flags
= VM_DATA_DEFAULT_FLAGS
|VM_GROWSUP
|VM_ACCOUNT
;
121 vma
->vm_page_prot
= vm_get_page_prot(vma
->vm_flags
);
122 down_write(¤t
->mm
->mmap_sem
);
123 if (insert_vm_struct(current
->mm
, vma
)) {
124 up_write(¤t
->mm
->mmap_sem
);
128 up_write(¤t
->mm
->mmap_sem
);
131 /* map NaT-page at address zero to speed up speculative dereferencing of NULL: */
132 if (!(current
->personality
& MMAP_PAGE_ZERO
)) {
133 vma
= vm_area_alloc(current
->mm
);
135 vma_set_anonymous(vma
);
136 vma
->vm_end
= PAGE_SIZE
;
137 vma
->vm_page_prot
= __pgprot(pgprot_val(PAGE_READONLY
) | _PAGE_MA_NAT
);
138 vma
->vm_flags
= VM_READ
| VM_MAYREAD
| VM_IO
|
139 VM_DONTEXPAND
| VM_DONTDUMP
;
140 down_write(¤t
->mm
->mmap_sem
);
141 if (insert_vm_struct(current
->mm
, vma
)) {
142 up_write(¤t
->mm
->mmap_sem
);
146 up_write(¤t
->mm
->mmap_sem
);
154 free_reserved_area(ia64_imva(__init_begin
), ia64_imva(__init_end
),
155 -1, "unused kernel");
159 free_initrd_mem (unsigned long start
, unsigned long end
)
162 * EFI uses 4KB pages while the kernel can use 4KB or bigger.
163 * Thus EFI and the kernel may have different page sizes. It is
164 * therefore possible to have the initrd share the same page as
165 * the end of the kernel (given current setup).
167 * To avoid freeing/using the wrong page (kernel sized) we:
168 * - align up the beginning of initrd
169 * - align down the end of initrd
172 * |=============| a000
178 * |=============| 8000
181 * |/////////////| 7000
184 * |=============| 6000
187 * K=kernel using 8KB pages
189 * In this example, we must free page 8000 ONLY. So we must align up
190 * initrd_start and keep initrd_end as is.
192 start
= PAGE_ALIGN(start
);
193 end
= end
& PAGE_MASK
;
196 printk(KERN_INFO
"Freeing initrd memory: %ldkB freed\n", (end
- start
) >> 10);
198 for (; start
< end
; start
+= PAGE_SIZE
) {
199 if (!virt_addr_valid(start
))
201 free_reserved_page(virt_to_page(start
));
206 * This installs a clean page in the kernel's page table.
208 static struct page
* __init
209 put_kernel_page (struct page
*page
, unsigned long address
, pgprot_t pgprot
)
216 pgd
= pgd_offset_k(address
); /* note: this is NOT pgd_offset()! */
219 pud
= pud_alloc(&init_mm
, pgd
, address
);
222 pmd
= pmd_alloc(&init_mm
, pud
, address
);
225 pte
= pte_alloc_kernel(pmd
, address
);
230 set_pte(pte
, mk_pte(page
, pgprot
));
233 /* no need for flush_tlb */
243 * Map the gate page twice: once read-only to export the ELF
244 * headers etc. and once execute-only page to enable
245 * privilege-promotion via "epc":
247 page
= virt_to_page(ia64_imva(__start_gate_section
));
248 put_kernel_page(page
, GATE_ADDR
, PAGE_READONLY
);
249 #ifdef HAVE_BUGGY_SEGREL
250 page
= virt_to_page(ia64_imva(__start_gate_section
+ PAGE_SIZE
));
251 put_kernel_page(page
, GATE_ADDR
+ PAGE_SIZE
, PAGE_GATE
);
253 put_kernel_page(page
, GATE_ADDR
+ PERCPU_PAGE_SIZE
, PAGE_GATE
);
254 /* Fill in the holes (if any) with read-only zero pages: */
258 for (addr
= GATE_ADDR
+ PAGE_SIZE
;
259 addr
< GATE_ADDR
+ PERCPU_PAGE_SIZE
;
262 put_kernel_page(ZERO_PAGE(0), addr
,
264 put_kernel_page(ZERO_PAGE(0), addr
+ PERCPU_PAGE_SIZE
,
272 static struct vm_area_struct gate_vma
;
274 static int __init
gate_vma_init(void)
276 vma_init(&gate_vma
, NULL
);
277 gate_vma
.vm_start
= FIXADDR_USER_START
;
278 gate_vma
.vm_end
= FIXADDR_USER_END
;
279 gate_vma
.vm_flags
= VM_READ
| VM_MAYREAD
| VM_EXEC
| VM_MAYEXEC
;
280 gate_vma
.vm_page_prot
= __P101
;
284 __initcall(gate_vma_init
);
286 struct vm_area_struct
*get_gate_vma(struct mm_struct
*mm
)
291 int in_gate_area_no_mm(unsigned long addr
)
293 if ((addr
>= FIXADDR_USER_START
) && (addr
< FIXADDR_USER_END
))
298 int in_gate_area(struct mm_struct
*mm
, unsigned long addr
)
300 return in_gate_area_no_mm(addr
);
303 void ia64_mmu_init(void *my_cpu_data
)
305 unsigned long pta
, impl_va_bits
;
306 extern void tlb_init(void);
308 #ifdef CONFIG_DISABLE_VHPT
309 # define VHPT_ENABLE_BIT 0
311 # define VHPT_ENABLE_BIT 1
315 * Check if the virtually mapped linear page table (VMLPT) overlaps with a mapped
316 * address space. The IA-64 architecture guarantees that at least 50 bits of
317 * virtual address space are implemented but if we pick a large enough page size
318 * (e.g., 64KB), the mapped address space is big enough that it will overlap with
319 * VMLPT. I assume that once we run on machines big enough to warrant 64KB pages,
320 * IMPL_VA_MSB will be significantly bigger, so this is unlikely to become a
321 * problem in practice. Alternatively, we could truncate the top of the mapped
322 * address space to not permit mappings that would overlap with the VMLPT.
326 # define mapped_space_bits (3*(PAGE_SHIFT - pte_bits) + PAGE_SHIFT)
328 * The virtual page table has to cover the entire implemented address space within
329 * a region even though not all of this space may be mappable. The reason for
330 * this is that the Access bit and Dirty bit fault handlers perform
331 * non-speculative accesses to the virtual page table, so the address range of the
332 * virtual page table itself needs to be covered by virtual page table.
334 # define vmlpt_bits (impl_va_bits - PAGE_SHIFT + pte_bits)
335 # define POW2(n) (1ULL << (n))
337 impl_va_bits
= ffz(~(local_cpu_data
->unimpl_va_mask
| (7UL << 61)));
339 if (impl_va_bits
< 51 || impl_va_bits
> 61)
340 panic("CPU has bogus IMPL_VA_MSB value of %lu!\n", impl_va_bits
- 1);
342 * mapped_space_bits - PAGE_SHIFT is the total number of ptes we need,
343 * which must fit into "vmlpt_bits - pte_bits" slots. Second half of
344 * the test makes sure that our mapped space doesn't overlap the
345 * unimplemented hole in the middle of the region.
347 if ((mapped_space_bits
- PAGE_SHIFT
> vmlpt_bits
- pte_bits
) ||
348 (mapped_space_bits
> impl_va_bits
- 1))
349 panic("Cannot build a big enough virtual-linear page table"
350 " to cover mapped address space.\n"
351 " Try using a smaller page size.\n");
354 /* place the VMLPT at the end of each page-table mapped region: */
355 pta
= POW2(61) - POW2(vmlpt_bits
);
358 * Set the (virtually mapped linear) page table address. Bit
359 * 8 selects between the short and long format, bits 2-7 the
360 * size of the table, and bit 0 whether the VHPT walker is
363 ia64_set_pta(pta
| (0 << 8) | (vmlpt_bits
<< 2) | VHPT_ENABLE_BIT
);
367 #ifdef CONFIG_HUGETLB_PAGE
368 ia64_set_rr(HPAGE_REGION_BASE
, HPAGE_SHIFT
<< 2);
373 #ifdef CONFIG_VIRTUAL_MEM_MAP
374 int vmemmap_find_next_valid_pfn(int node
, int i
)
376 unsigned long end_address
, hole_next_pfn
;
377 unsigned long stop_address
;
378 pg_data_t
*pgdat
= NODE_DATA(node
);
380 end_address
= (unsigned long) &vmem_map
[pgdat
->node_start_pfn
+ i
];
381 end_address
= PAGE_ALIGN(end_address
);
382 stop_address
= (unsigned long) &vmem_map
[pgdat_end_pfn(pgdat
)];
390 pgd
= pgd_offset_k(end_address
);
391 if (pgd_none(*pgd
)) {
392 end_address
+= PGDIR_SIZE
;
396 pud
= pud_offset(pgd
, end_address
);
397 if (pud_none(*pud
)) {
398 end_address
+= PUD_SIZE
;
402 pmd
= pmd_offset(pud
, end_address
);
403 if (pmd_none(*pmd
)) {
404 end_address
+= PMD_SIZE
;
408 pte
= pte_offset_kernel(pmd
, end_address
);
410 if (pte_none(*pte
)) {
411 end_address
+= PAGE_SIZE
;
413 if ((end_address
< stop_address
) &&
414 (end_address
!= ALIGN(end_address
, 1UL << PMD_SHIFT
)))
418 /* Found next valid vmem_map page */
420 } while (end_address
< stop_address
);
422 end_address
= min(end_address
, stop_address
);
423 end_address
= end_address
- (unsigned long) vmem_map
+ sizeof(struct page
) - 1;
424 hole_next_pfn
= end_address
/ sizeof(struct page
);
425 return hole_next_pfn
- pgdat
->node_start_pfn
;
428 int __init
create_mem_map_page_table(u64 start
, u64 end
, void *arg
)
430 unsigned long address
, start_page
, end_page
;
431 struct page
*map_start
, *map_end
;
438 map_start
= vmem_map
+ (__pa(start
) >> PAGE_SHIFT
);
439 map_end
= vmem_map
+ (__pa(end
) >> PAGE_SHIFT
);
441 start_page
= (unsigned long) map_start
& PAGE_MASK
;
442 end_page
= PAGE_ALIGN((unsigned long) map_end
);
443 node
= paddr_to_nid(__pa(start
));
445 for (address
= start_page
; address
< end_page
; address
+= PAGE_SIZE
) {
446 pgd
= pgd_offset_k(address
);
448 pgd_populate(&init_mm
, pgd
, memblock_alloc_node(PAGE_SIZE
, PAGE_SIZE
, node
));
449 pud
= pud_offset(pgd
, address
);
452 pud_populate(&init_mm
, pud
, memblock_alloc_node(PAGE_SIZE
, PAGE_SIZE
, node
));
453 pmd
= pmd_offset(pud
, address
);
456 pmd_populate_kernel(&init_mm
, pmd
, memblock_alloc_node(PAGE_SIZE
, PAGE_SIZE
, node
));
457 pte
= pte_offset_kernel(pmd
, address
);
460 set_pte(pte
, pfn_pte(__pa(memblock_alloc_node(PAGE_SIZE
, PAGE_SIZE
, node
)) >> PAGE_SHIFT
,
466 struct memmap_init_callback_data
{
474 virtual_memmap_init(u64 start
, u64 end
, void *arg
)
476 struct memmap_init_callback_data
*args
;
477 struct page
*map_start
, *map_end
;
479 args
= (struct memmap_init_callback_data
*) arg
;
480 map_start
= vmem_map
+ (__pa(start
) >> PAGE_SHIFT
);
481 map_end
= vmem_map
+ (__pa(end
) >> PAGE_SHIFT
);
483 if (map_start
< args
->start
)
484 map_start
= args
->start
;
485 if (map_end
> args
->end
)
489 * We have to initialize "out of bounds" struct page elements that fit completely
490 * on the same pages that were allocated for the "in bounds" elements because they
491 * may be referenced later (and found to be "reserved").
493 map_start
-= ((unsigned long) map_start
& (PAGE_SIZE
- 1)) / sizeof(struct page
);
494 map_end
+= ((PAGE_ALIGN((unsigned long) map_end
) - (unsigned long) map_end
)
495 / sizeof(struct page
));
497 if (map_start
< map_end
)
498 memmap_init_zone((unsigned long)(map_end
- map_start
),
499 args
->nid
, args
->zone
, page_to_pfn(map_start
),
505 memmap_init (unsigned long size
, int nid
, unsigned long zone
,
506 unsigned long start_pfn
)
509 memmap_init_zone(size
, nid
, zone
, start_pfn
, MEMMAP_EARLY
,
513 struct memmap_init_callback_data args
;
515 start
= pfn_to_page(start_pfn
);
517 args
.end
= start
+ size
;
521 efi_memmap_walk(virtual_memmap_init
, &args
);
526 ia64_pfn_valid (unsigned long pfn
)
529 struct page
*pg
= pfn_to_page(pfn
);
531 return (__get_user(byte
, (char __user
*) pg
) == 0)
532 && ((((u64
)pg
& PAGE_MASK
) == (((u64
)(pg
+ 1) - 1) & PAGE_MASK
))
533 || (__get_user(byte
, (char __user
*) (pg
+ 1) - 1) == 0));
535 EXPORT_SYMBOL(ia64_pfn_valid
);
537 int __init
find_largest_hole(u64 start
, u64 end
, void *arg
)
541 static u64 last_end
= PAGE_OFFSET
;
543 /* NOTE: this algorithm assumes efi memmap table is ordered */
545 if (*max_gap
< (start
- last_end
))
546 *max_gap
= start
- last_end
;
551 #endif /* CONFIG_VIRTUAL_MEM_MAP */
553 int __init
register_active_ranges(u64 start
, u64 len
, int nid
)
555 u64 end
= start
+ len
;
558 if (start
> crashk_res
.start
&& start
< crashk_res
.end
)
559 start
= crashk_res
.end
;
560 if (end
> crashk_res
.start
&& end
< crashk_res
.end
)
561 end
= crashk_res
.start
;
565 memblock_add_node(__pa(start
), end
- start
, nid
);
570 find_max_min_low_pfn (u64 start
, u64 end
, void *arg
)
572 unsigned long pfn_start
, pfn_end
;
573 #ifdef CONFIG_FLATMEM
574 pfn_start
= (PAGE_ALIGN(__pa(start
))) >> PAGE_SHIFT
;
575 pfn_end
= (PAGE_ALIGN(__pa(end
- 1))) >> PAGE_SHIFT
;
577 pfn_start
= GRANULEROUNDDOWN(__pa(start
)) >> PAGE_SHIFT
;
578 pfn_end
= GRANULEROUNDUP(__pa(end
- 1)) >> PAGE_SHIFT
;
580 min_low_pfn
= min(min_low_pfn
, pfn_start
);
581 max_low_pfn
= max(max_low_pfn
, pfn_end
);
586 * Boot command-line option "nolwsys" can be used to disable the use of any light-weight
587 * system call handler. When this option is in effect, all fsyscalls will end up bubbling
588 * down into the kernel and calling the normal (heavy-weight) syscall handler. This is
589 * useful for performance testing, but conceivably could also come in handy for debugging
593 static int nolwsys __initdata
;
596 nolwsys_setup (char *s
)
602 __setup("nolwsys", nolwsys_setup
);
609 BUG_ON(PTRS_PER_PGD
* sizeof(pgd_t
) != PAGE_SIZE
);
610 BUG_ON(PTRS_PER_PMD
* sizeof(pmd_t
) != PAGE_SIZE
);
611 BUG_ON(PTRS_PER_PTE
* sizeof(pte_t
) != PAGE_SIZE
);
615 * This needs to be called _after_ the command line has been parsed but _before_
616 * any drivers that may need the PCI DMA interface are initialized or bootmem has
622 #ifdef CONFIG_FLATMEM
626 set_max_mapnr(max_low_pfn
);
627 high_memory
= __va(max_low_pfn
* PAGE_SIZE
);
629 mem_init_print_info(NULL
);
632 * For fsyscall entrpoints with no light-weight handler, use the ordinary
633 * (heavy-weight) handler, but mark it by setting bit 0, so the fsyscall entry
634 * code can tell them apart.
636 for (i
= 0; i
< NR_syscalls
; ++i
) {
637 extern unsigned long fsyscall_table
[NR_syscalls
];
638 extern unsigned long sys_call_table
[NR_syscalls
];
640 if (!fsyscall_table
[i
] || nolwsys
)
641 fsyscall_table
[i
] = sys_call_table
[i
] | 1;
646 #ifdef CONFIG_MEMORY_HOTPLUG
647 int arch_add_memory(int nid
, u64 start
, u64 size
, struct vmem_altmap
*altmap
,
650 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
651 unsigned long nr_pages
= size
>> PAGE_SHIFT
;
654 ret
= __add_pages(nid
, start_pfn
, nr_pages
, altmap
, want_memblock
);
656 printk("%s: Problem encountered in __add_pages() as ret=%d\n",
662 #ifdef CONFIG_MEMORY_HOTREMOVE
663 int arch_remove_memory(int nid
, u64 start
, u64 size
, struct vmem_altmap
*altmap
)
665 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
666 unsigned long nr_pages
= size
>> PAGE_SHIFT
;
670 zone
= page_zone(pfn_to_page(start_pfn
));
671 ret
= __remove_pages(zone
, start_pfn
, nr_pages
, altmap
);
673 pr_warn("%s: Problem encountered in __remove_pages() as"
674 " ret=%d\n", __func__
, ret
);