~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/alpha/mm/init.c

Version: ~ [ linux-5.13-rc7 ] ~ [ linux-5.12.12 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.45 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.127 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.195 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.237 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.273 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.273 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp