xref: /openbmc/linux/arch/um/kernel/mem.c (revision 2b77dcc5)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
4  */
5 
6 #include <linux/stddef.h>
7 #include <linux/module.h>
8 #include <linux/memblock.h>
9 #include <linux/highmem.h>
10 #include <linux/mm.h>
11 #include <linux/swap.h>
12 #include <linux/slab.h>
13 #include <asm/fixmap.h>
14 #include <asm/page.h>
15 #include <as-layout.h>
16 #include <init.h>
17 #include <kern.h>
18 #include <kern_util.h>
19 #include <mem_user.h>
20 #include <os.h>
21 
22 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
23 unsigned long *empty_zero_page = NULL;
24 EXPORT_SYMBOL(empty_zero_page);
25 
26 /*
27  * Initialized during boot, and readonly for initializing page tables
28  * afterwards
29  */
30 pgd_t swapper_pg_dir[PTRS_PER_PGD];
31 
32 /* Initialized at boot time, and readonly after that */
33 unsigned long long highmem;
34 EXPORT_SYMBOL(highmem);
35 int kmalloc_ok = 0;
36 
37 /* Used during early boot */
38 static unsigned long brk_end;
39 
40 void __init mem_init(void)
41 {
42 	/* clear the zero-page */
43 	memset(empty_zero_page, 0, PAGE_SIZE);
44 
45 	/* Map in the area just after the brk now that kmalloc is about
46 	 * to be turned on.
47 	 */
48 	brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
49 	map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
50 	memblock_free(__pa(brk_end), uml_reserved - brk_end);
51 	uml_reserved = brk_end;
52 
53 	/* this will put all low memory onto the freelists */
54 	memblock_free_all();
55 	max_low_pfn = totalram_pages();
56 	max_pfn = max_low_pfn;
57 	mem_init_print_info(NULL);
58 	kmalloc_ok = 1;
59 }
60 
61 /*
62  * Create a page table and place a pointer to it in a middle page
63  * directory entry.
64  */
65 static void __init one_page_table_init(pmd_t *pmd)
66 {
67 	if (pmd_none(*pmd)) {
68 		pte_t *pte = (pte_t *) memblock_alloc_low(PAGE_SIZE,
69 							  PAGE_SIZE);
70 		if (!pte)
71 			panic("%s: Failed to allocate %lu bytes align=%lx\n",
72 			      __func__, PAGE_SIZE, PAGE_SIZE);
73 
74 		set_pmd(pmd, __pmd(_KERNPG_TABLE +
75 					   (unsigned long) __pa(pte)));
76 		if (pte != pte_offset_kernel(pmd, 0))
77 			BUG();
78 	}
79 }
80 
81 static void __init one_md_table_init(pud_t *pud)
82 {
83 #ifdef CONFIG_3_LEVEL_PGTABLES
84 	pmd_t *pmd_table = (pmd_t *) memblock_alloc_low(PAGE_SIZE, PAGE_SIZE);
85 	if (!pmd_table)
86 		panic("%s: Failed to allocate %lu bytes align=%lx\n",
87 		      __func__, PAGE_SIZE, PAGE_SIZE);
88 
89 	set_pud(pud, __pud(_KERNPG_TABLE + (unsigned long) __pa(pmd_table)));
90 	if (pmd_table != pmd_offset(pud, 0))
91 		BUG();
92 #endif
93 }
94 
95 static void __init fixrange_init(unsigned long start, unsigned long end,
96 				 pgd_t *pgd_base)
97 {
98 	pgd_t *pgd;
99 	pud_t *pud;
100 	pmd_t *pmd;
101 	int i, j;
102 	unsigned long vaddr;
103 
104 	vaddr = start;
105 	i = pgd_index(vaddr);
106 	j = pmd_index(vaddr);
107 	pgd = pgd_base + i;
108 
109 	for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
110 		pud = pud_offset(pgd, vaddr);
111 		if (pud_none(*pud))
112 			one_md_table_init(pud);
113 		pmd = pmd_offset(pud, vaddr);
114 		for (; (j < PTRS_PER_PMD) && (vaddr < end); pmd++, j++) {
115 			one_page_table_init(pmd);
116 			vaddr += PMD_SIZE;
117 		}
118 		j = 0;
119 	}
120 }
121 
122 static void __init fixaddr_user_init( void)
123 {
124 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
125 	long size = FIXADDR_USER_END - FIXADDR_USER_START;
126 	pgd_t *pgd;
127 	pud_t *pud;
128 	pmd_t *pmd;
129 	pte_t *pte;
130 	phys_t p;
131 	unsigned long v, vaddr = FIXADDR_USER_START;
132 
133 	if (!size)
134 		return;
135 
136 	fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
137 	v = (unsigned long) memblock_alloc_low(size, PAGE_SIZE);
138 	if (!v)
139 		panic("%s: Failed to allocate %lu bytes align=%lx\n",
140 		      __func__, size, PAGE_SIZE);
141 
142 	memcpy((void *) v , (void *) FIXADDR_USER_START, size);
143 	p = __pa(v);
144 	for ( ; size > 0; size -= PAGE_SIZE, vaddr += PAGE_SIZE,
145 		      p += PAGE_SIZE) {
146 		pgd = swapper_pg_dir + pgd_index(vaddr);
147 		pud = pud_offset(pgd, vaddr);
148 		pmd = pmd_offset(pud, vaddr);
149 		pte = pte_offset_kernel(pmd, vaddr);
150 		pte_set_val(*pte, p, PAGE_READONLY);
151 	}
152 #endif
153 }
154 
155 void __init paging_init(void)
156 {
157 	unsigned long zones_size[MAX_NR_ZONES], vaddr;
158 	int i;
159 
160 	empty_zero_page = (unsigned long *) memblock_alloc_low(PAGE_SIZE,
161 							       PAGE_SIZE);
162 	if (!empty_zero_page)
163 		panic("%s: Failed to allocate %lu bytes align=%lx\n",
164 		      __func__, PAGE_SIZE, PAGE_SIZE);
165 
166 	for (i = 0; i < ARRAY_SIZE(zones_size); i++)
167 		zones_size[i] = 0;
168 
169 	zones_size[ZONE_NORMAL] = (end_iomem >> PAGE_SHIFT) -
170 		(uml_physmem >> PAGE_SHIFT);
171 	free_area_init(zones_size);
172 
173 	/*
174 	 * Fixed mappings, only the page table structure has to be
175 	 * created - mappings will be set by set_fixmap():
176 	 */
177 	vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
178 	fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);
179 
180 	fixaddr_user_init();
181 }
182 
183 /*
184  * This can't do anything because nothing in the kernel image can be freed
185  * since it's not in kernel physical memory.
186  */
187 
188 void free_initmem(void)
189 {
190 }
191 
192 /* Allocate and free page tables. */
193 
194 pgd_t *pgd_alloc(struct mm_struct *mm)
195 {
196 	pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);
197 
198 	if (pgd) {
199 		memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
200 		memcpy(pgd + USER_PTRS_PER_PGD,
201 		       swapper_pg_dir + USER_PTRS_PER_PGD,
202 		       (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
203 	}
204 	return pgd;
205 }
206 
207 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
208 {
209 	free_page((unsigned long) pgd);
210 }
211 
212 #ifdef CONFIG_3_LEVEL_PGTABLES
213 pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
214 {
215 	pmd_t *pmd = (pmd_t *) __get_free_page(GFP_KERNEL);
216 
217 	if (pmd)
218 		memset(pmd, 0, PAGE_SIZE);
219 
220 	return pmd;
221 }
222 #endif
223 
224 void *uml_kmalloc(int size, int flags)
225 {
226 	return kmalloc(size, flags);
227 }
228