init.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * Copyright (C) 2020-2022 Loongson Technology Corporation Limited
  4 */
  5#include <linux/init.h>
  6#include <linux/export.h>
  7#include <linux/signal.h>
  8#include <linux/sched.h>
  9#include <linux/smp.h>
 10#include <linux/kernel.h>
 11#include <linux/errno.h>
 12#include <linux/string.h>
 13#include <linux/types.h>
 14#include <linux/pagemap.h>
 15#include <linux/memblock.h>
 16#include <linux/memremap.h>
 17#include <linux/mm.h>
 18#include <linux/mman.h>
 19#include <linux/highmem.h>
 20#include <linux/swap.h>
 21#include <linux/proc_fs.h>
 22#include <linux/pfn.h>
 23#include <linux/hardirq.h>
 24#include <linux/gfp.h>
 25#include <linux/hugetlb.h>
 26#include <linux/mmzone.h>
 27#include <linux/execmem.h>
 28
 29#include <asm/asm-offsets.h>
 30#include <asm/bootinfo.h>
 31#include <asm/cpu.h>
 32#include <asm/dma.h>
 33#include <asm/mmu_context.h>
 34#include <asm/sections.h>
 35#include <asm/pgtable.h>
 36#include <asm/pgalloc.h>
 37#include <asm/tlb.h>
 38
 39unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] __page_aligned_bss;
 40EXPORT_SYMBOL(empty_zero_page);
 41
 42void copy_user_highpage(struct page *to, struct page *from,
 43	unsigned long vaddr, struct vm_area_struct *vma)
 44{
 45	void *vfrom, *vto;
 46
 47	vfrom = kmap_local_page(from);
 48	vto = kmap_local_page(to);
 49	copy_page(vto, vfrom);
 50	kunmap_local(vfrom);
 51	kunmap_local(vto);
 52	/* Make sure this page is cleared on other CPU's too before using it */
 53	smp_wmb();
 54}
 55
 56int __ref page_is_ram(unsigned long pfn)
 57{
 58	unsigned long addr = PFN_PHYS(pfn);
 59
 60	return memblock_is_memory(addr) && !memblock_is_reserved(addr);
 61}
 62
 63void __init paging_init(void)
 64{
 65	unsigned long max_zone_pfns[MAX_NR_ZONES];
 66
 67#ifdef CONFIG_ZONE_DMA32
 68	max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
 69#endif
 70	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
 71
 72	free_area_init(max_zone_pfns);
 73}
 74
 75void __ref free_initmem(void)
 76{
 77	free_initmem_default(POISON_FREE_INITMEM);
 78}
 79
 80#ifdef CONFIG_MEMORY_HOTPLUG
 81int arch_add_memory(int nid, u64 start, u64 size, struct mhp_params *params)
 82{
 83	unsigned long start_pfn = start >> PAGE_SHIFT;
 84	unsigned long nr_pages = size >> PAGE_SHIFT;
 85	int ret;
 86
 87	ret = __add_pages(nid, start_pfn, nr_pages, params);
 88
 89	if (ret)
 90		pr_warn("%s: Problem encountered in __add_pages() as ret=%d\n",
 91				__func__,  ret);
 92
 93	return ret;
 94}
 95
 96void arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
 97{
 98	unsigned long start_pfn = start >> PAGE_SHIFT;
 99	unsigned long nr_pages = size >> PAGE_SHIFT;
100	struct page *page = pfn_to_page(start_pfn);
101
102	/* With altmap the first mapped page is offset from @start */
103	if (altmap)
104		page += vmem_altmap_offset(altmap);
105	__remove_pages(start_pfn, nr_pages, altmap);
106}
107#endif
108
109#ifdef CONFIG_SPARSEMEM_VMEMMAP
110void __meminit vmemmap_set_pmd(pmd_t *pmd, void *p, int node,
111			       unsigned long addr, unsigned long next)
112{
113	pmd_t entry;
114
115	entry = pfn_pmd(virt_to_pfn(p), PAGE_KERNEL);
116	pmd_val(entry) |= _PAGE_HUGE | _PAGE_HGLOBAL;
117	set_pmd_at(&init_mm, addr, pmd, entry);
118}
119
120int __meminit vmemmap_check_pmd(pmd_t *pmd, int node,
121				unsigned long addr, unsigned long next)
122{
123	int huge = pmd_val(pmdp_get(pmd)) & _PAGE_HUGE;
124
125	if (huge)
126		vmemmap_verify((pte_t *)pmd, node, addr, next);
127
128	return huge;
129}
130
131int __meminit vmemmap_populate(unsigned long start, unsigned long end,
132			       int node, struct vmem_altmap *altmap)
133{
134#if CONFIG_PGTABLE_LEVELS == 2
135	return vmemmap_populate_basepages(start, end, node, NULL);
136#else
137	return vmemmap_populate_hugepages(start, end, node, NULL);
138#endif
139}
140
141#ifdef CONFIG_MEMORY_HOTPLUG
142void vmemmap_free(unsigned long start, unsigned long end, struct vmem_altmap *altmap)
143{
144}
145#endif
146#endif
147
148pte_t * __init populate_kernel_pte(unsigned long addr)
149{
150	pgd_t *pgd = pgd_offset_k(addr);
151	p4d_t *p4d = p4d_offset(pgd, addr);
152	pud_t *pud;
153	pmd_t *pmd;
154
155	if (p4d_none(p4dp_get(p4d))) {
156		pud = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE);
157		p4d_populate(&init_mm, p4d, pud);
158#ifndef __PAGETABLE_PUD_FOLDED
159		pud_init(pud);
160#endif
161	}
162
163	pud = pud_offset(p4d, addr);
164	if (pud_none(pudp_get(pud))) {
165		pmd = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE);
166		pud_populate(&init_mm, pud, pmd);
167#ifndef __PAGETABLE_PMD_FOLDED
168		pmd_init(pmd);
169#endif
170	}
171
172	pmd = pmd_offset(pud, addr);
173	if (!pmd_present(pmdp_get(pmd))) {
174		pte_t *pte;
175
176		pte = memblock_alloc_or_panic(PAGE_SIZE, PAGE_SIZE);
177		pmd_populate_kernel(&init_mm, pmd, pte);
178		kernel_pte_init(pte);
179	}
180
181	return pte_offset_kernel(pmd, addr);
182}
183
184void __init __set_fixmap(enum fixed_addresses idx,
185			       phys_addr_t phys, pgprot_t flags)
186{
187	unsigned long addr = __fix_to_virt(idx);
188	pte_t *ptep;
189
190	BUG_ON(idx <= FIX_HOLE || idx >= __end_of_fixed_addresses);
191
192	ptep = populate_kernel_pte(addr);
193	if (!pte_none(ptep_get(ptep))) {
194		pte_ERROR(*ptep);
195		return;
196	}
197
198	if (pgprot_val(flags))
199		set_pte(ptep, pfn_pte(phys >> PAGE_SHIFT, flags));
200	else {
201		pte_clear(&init_mm, addr, ptep);
202		flush_tlb_kernel_range(addr, addr + PAGE_SIZE);
203	}
204}
205
206/*
207 * Align swapper_pg_dir in to 64K, allows its address to be loaded
208 * with a single LUI instruction in the TLB handlers.  If we used
209 * __aligned(64K), its size would get rounded up to the alignment
210 * size, and waste space.  So we place it in its own section and align
211 * it in the linker script.
212 */
213pgd_t swapper_pg_dir[_PTRS_PER_PGD] __section(".bss..swapper_pg_dir");
214
215pgd_t invalid_pg_dir[_PTRS_PER_PGD] __page_aligned_bss;
216#ifndef __PAGETABLE_PUD_FOLDED
217pud_t invalid_pud_table[PTRS_PER_PUD] __page_aligned_bss;
218EXPORT_SYMBOL(invalid_pud_table);
219#endif
220#ifndef __PAGETABLE_PMD_FOLDED
221pmd_t invalid_pmd_table[PTRS_PER_PMD] __page_aligned_bss;
222EXPORT_SYMBOL(invalid_pmd_table);
223#endif
224pte_t invalid_pte_table[PTRS_PER_PTE] __page_aligned_bss;
225EXPORT_SYMBOL(invalid_pte_table);
226
227#if defined(CONFIG_EXECMEM) && defined(MODULES_VADDR)
228static struct execmem_info execmem_info __ro_after_init;
229
230struct execmem_info __init *execmem_arch_setup(void)
231{
232	execmem_info = (struct execmem_info){
233		.ranges = {
234			[EXECMEM_DEFAULT] = {
235				.start	= MODULES_VADDR,
236				.end	= MODULES_END,
237				.pgprot	= PAGE_KERNEL,
238				.alignment = 1,
239			},
240		},
241	};
242
243	return &execmem_info;
244}
245#endif /* CONFIG_EXECMEM && MODULES_VADDR */