1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * linux/arch/alpha/mm/init.c
4 *
5 * Copyright (C) 1995 Linus Torvalds
6 */
7
8 /* 2.3.x zone allocator, 1999 Andrea Arcangeli <andrea@suse.de> */
9
10 #include <linux/pagemap.h>
11 #include <linux/signal.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/string.h>
16 #include <linux/types.h>
17 #include <linux/ptrace.h>
18 #include <linux/mman.h>
19 #include <linux/mm.h>
20 #include <linux/swap.h>
21 #include <linux/init.h>
22 #include <linux/memblock.h> /* max_low_pfn */
23 #include <linux/vmalloc.h>
24 #include <linux/gfp.h>
25
26 #include <linux/uaccess.h>
27 #include <asm/pgalloc.h>
28 #include <asm/hwrpb.h>
29 #include <asm/dma.h>
30 #include <asm/mmu_context.h>
31 #include <asm/console.h>
32 #include <asm/tlb.h>
33 #include <asm/setup.h>
34 #include <asm/sections.h>
35
36 #include "../kernel/proto.h"
37
38 static struct pcb_struct original_pcb;
39
40 pgd_t *
41 pgd_alloc(struct mm_struct *mm)
42 {
43 pgd_t *ret, *init;
44
45 ret = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
46 init = pgd_offset(&init_mm, 0UL);
47 if (ret) {
48 #ifdef CONFIG_ALPHA_LARGE_VMALLOC
49 memcpy (ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
50 (PTRS_PER_PGD - USER_PTRS_PER_PGD - 1)*sizeof(pgd_t));
51 #else
52 pgd_val(ret[PTRS_PER_PGD-2]) = pgd_val(init[PTRS_PER_PGD-2]);
53 #endif
54
55 /* The last PGD entry is the VPTB self-map. */
56 pgd_val(ret[PTRS_PER_PGD-1])
57 = pte_val(mk_pte(virt_to_page(ret), PAGE_KERNEL));
58 }
59 return ret;
60 }
61
62
63 /*
64 * BAD_PAGE is the page that is used for page faults when linux
65 * is out-of-memory. Older versions of linux just did a
66 * do_exit(), but using this instead means there is less risk
67 * for a process dying in kernel mode, possibly leaving an inode
68 * unused etc..
69 *
70 * BAD_PAGETABLE is the accompanying page-table: it is initialized
71 * to point to BAD_PAGE entries.
72 *
73 * ZERO_PAGE is a special page that is used for zero-initialized
74 * data and COW.
75 */
76 pmd_t *
77 __bad_pagetable(void)
78 {
79 memset(absolute_pointer(EMPTY_PGT), 0, PAGE_SIZE);
80 return (pmd_t *) EMPTY_PGT;
81 }
82
83 pte_t
84 __bad_page(void)
85 {
86 memset(absolute_pointer(EMPTY_PGE), 0, PAGE_SIZE);
87 return pte_mkdirty(mk_pte(virt_to_page(EMPTY_PGE), PAGE_SHARED));
88 }
89
90 static inline unsigned long
91 load_PCB(struct pcb_struct *pcb)
92 {
93 register unsigned long sp __asm__("$30");
94 pcb->ksp = sp;
95 return __reload_thread(pcb);
96 }
97
98 /* Set up initial PCB, VPTB, and other such nicities. */
99
100 static inline void
101 switch_to_system_map(void)
102 {
103 unsigned long newptbr;
104 unsigned long original_pcb_ptr;
105
106 /* Initialize the kernel's page tables. Linux puts the vptb in
107 the last slot of the L1 page table. */
108 memset(swapper_pg_dir, 0, PAGE_SIZE);
109 newptbr = ((unsigned long) swapper_pg_dir - PAGE_OFFSET) >> PAGE_SHIFT;
110 pgd_val(swapper_pg_dir[1023]) =
111 (newptbr << 32) | pgprot_val(PAGE_KERNEL);
112
113 /* Set the vptb. This is often done by the bootloader, but
114 shouldn't be required. */
115 if (hwrpb->vptb != 0xfffffffe00000000UL) {
116 wrvptptr(0xfffffffe00000000UL);
117 hwrpb->vptb = 0xfffffffe00000000UL;
118 hwrpb_update_checksum(hwrpb);
119 }
120
121 /* Also set up the real kernel PCB while we're at it. */
122 init_thread_info.pcb.ptbr = newptbr;
123 init_thread_info.pcb.flags = 1; /* set FEN, clear everything else */
124 original_pcb_ptr = load_PCB(&init_thread_info.pcb);
125 tbia();
126
127 /* Save off the contents of the original PCB so that we can
128 restore the original console's page tables for a clean reboot.
129
130 Note that the PCB is supposed to be a physical address, but
131 since KSEG values also happen to work, folks get confused.
132 Check this here. */
133
134 if (original_pcb_ptr < PAGE_OFFSET) {
135 original_pcb_ptr = (unsigned long)
136 phys_to_virt(original_pcb_ptr);
137 }
138 original_pcb = *(struct pcb_struct *) original_pcb_ptr;
139 }
140
141 int callback_init_done;
142
143 void * __init
144 callback_init(void * kernel_end)
145 {
146 struct crb_struct * crb;
147 pgd_t *pgd;
148 p4d_t *p4d;
149 pud_t *pud;
150 pmd_t *pmd;
151 void *two_pages;
152
153 /* Starting at the HWRPB, locate the CRB. */
154 crb = (struct crb_struct *)((char *)hwrpb + hwrpb->crb_offset);
155
156 if (alpha_using_srm) {
157 /* Tell the console whither it is to be remapped. */
158 if (srm_fixup(VMALLOC_START, (unsigned long)hwrpb))
159 __halt(); /* "We're boned." --Bender */
160
161 /* Edit the procedure descriptors for DISPATCH and FIXUP. */
162 crb->dispatch_va = (struct procdesc_struct *)
163 (VMALLOC_START + (unsigned long)crb->dispatch_va
164 - crb->map[0].va);
165 crb->fixup_va = (struct procdesc_struct *)
166 (VMALLOC_START + (unsigned long)crb->fixup_va
167 - crb->map[0].va);
168 }
169
170 switch_to_system_map();
171
172 /* Allocate one PGD and one PMD. In the case of SRM, we'll need
173 these to actually remap the console. There is an assumption
174 here that only one of each is needed, and this allows for 8MB.
175 On systems with larger consoles, additional pages will be
176 allocated as needed during the mapping process.
177
178 In the case of not SRM, but not CONFIG_ALPHA_LARGE_VMALLOC,
179 we need to allocate the PGD we use for vmalloc before we start
180 forking other tasks. */
181
182 two_pages = (void *)
183 (((unsigned long)kernel_end + ~PAGE_MASK) & PAGE_MASK);
184 kernel_end = two_pages + 2*PAGE_SIZE;
185 memset(two_pages, 0, 2*PAGE_SIZE);
186
187 pgd = pgd_offset_k(VMALLOC_START);
188 p4d = p4d_offset(pgd, VMALLOC_START);
189 pud = pud_offset(p4d, VMALLOC_START);
190 pud_set(pud, (pmd_t *)two_pages);
191 pmd = pmd_offset(pud, VMALLOC_START);
192 pmd_set(pmd, (pte_t *)(two_pages + PAGE_SIZE));
193
194 if (alpha_using_srm) {
195 static struct vm_struct console_remap_vm;
196 unsigned long nr_pages = 0;
197 unsigned long vaddr;
198 unsigned long i, j;
199
200 /* calculate needed size */
201 for (i = 0; i < crb->map_entries; ++i)
202 nr_pages += crb->map[i].count;
203
204 /* register the vm area */
205 console_remap_vm.flags = VM_ALLOC;
206 console_remap_vm.size = nr_pages << PAGE_SHIFT;
207 vm_area_register_early(&console_remap_vm, PAGE_SIZE);
208
209 vaddr = (unsigned long)console_remap_vm.addr;
210
211 /* Set up the third level PTEs and update the virtual
212 addresses of the CRB entries. */
213 for (i = 0; i < crb->map_entries; ++i) {
214 unsigned long pfn = crb->map[i].pa >> PAGE_SHIFT;
215 crb->map[i].va = vaddr;
216 for (j = 0; j < crb->map[i].count; ++j) {
217 /* Newer consoles (especially on larger
218 systems) may require more pages of
219 PTEs. Grab additional pages as needed. */
220 if (pmd != pmd_offset(pud, vaddr)) {
221 memset(kernel_end, 0, PAGE_SIZE);
222 pmd = pmd_offset(pud, vaddr);
223 pmd_set(pmd, (pte_t *)kernel_end);
224 kernel_end += PAGE_SIZE;
225 }
226 set_pte(pte_offset_kernel(pmd, vaddr),
227 pfn_pte(pfn, PAGE_KERNEL));
228 pfn++;
229 vaddr += PAGE_SIZE;
230 }
231 }
232 }
233
234 callback_init_done = 1;
235 return kernel_end;
236 }
237
238 /*
239 * paging_init() sets up the memory map.
240 */
241 void __init paging_init(void)
242 {
243 unsigned long max_zone_pfn[MAX_NR_ZONES] = {0, };
244 unsigned long dma_pfn;
245
246 dma_pfn = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
247 max_pfn = max_low_pfn;
248
249 max_zone_pfn[ZONE_DMA] = dma_pfn;
250 max_zone_pfn[ZONE_NORMAL] = max_pfn;
251
252 /* Initialize mem_map[]. */
253 free_area_init(max_zone_pfn);
254
255 /* Initialize the kernel's ZERO_PGE. */
256 memset(absolute_pointer(ZERO_PGE), 0, PAGE_SIZE);
257 }
258
259 #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM)
260 void
261 srm_paging_stop (void)
262 {
263 /* Move the vptb back to where the SRM console expects it. */
264 swapper_pg_dir[1] = swapper_pg_dir[1023];
265 tbia();
266 wrvptptr(0x200000000UL);
267 hwrpb->vptb = 0x200000000UL;
268 hwrpb_update_checksum(hwrpb);
269
270 /* Reload the page tables that the console had in use. */
271 load_PCB(&original_pcb);
272 tbia();
273 }
274 #endif
275
276 void __init
277 mem_init(void)
278 {
279 set_max_mapnr(max_low_pfn);
280 high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
281 memblock_free_all();
282 }
283
284 static const pgprot_t protection_map[16] = {
285 [VM_NONE] = _PAGE_P(_PAGE_FOE | _PAGE_FOW |
286 _PAGE_FOR),
287 [VM_READ] = _PAGE_P(_PAGE_FOE | _PAGE_FOW),
288 [VM_WRITE] = _PAGE_P(_PAGE_FOE),
289 [VM_WRITE | VM_READ] = _PAGE_P(_PAGE_FOE),
290 [VM_EXEC] = _PAGE_P(_PAGE_FOW | _PAGE_FOR),
291 [VM_EXEC | VM_READ] = _PAGE_P(_PAGE_FOW),
292 [VM_EXEC | VM_WRITE] = _PAGE_P(0),
293 [VM_EXEC | VM_WRITE | VM_READ] = _PAGE_P(0),
294 [VM_SHARED] = _PAGE_S(_PAGE_FOE | _PAGE_FOW |
295 _PAGE_FOR),
296 [VM_SHARED | VM_READ] = _PAGE_S(_PAGE_FOE | _PAGE_FOW),
297 [VM_SHARED | VM_WRITE] = _PAGE_S(_PAGE_FOE),
298 [VM_SHARED | VM_WRITE | VM_READ] = _PAGE_S(_PAGE_FOE),
299 [VM_SHARED | VM_EXEC] = _PAGE_S(_PAGE_FOW | _PAGE_FOR),
300 [VM_SHARED | VM_EXEC | VM_READ] = _PAGE_S(_PAGE_FOW),
301 [VM_SHARED | VM_EXEC | VM_WRITE] = _PAGE_S(0),
302 [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = _PAGE_S(0)
303 };
304 DECLARE_VM_GET_PAGE_PROT
305
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.