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

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

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 /*
  2  *  linux/arch/alpha/mm/init.c
  3  *
  4  *  Copyright (C) 1995  Linus Torvalds
  5  */
  6 
  7 /* 2.3.x zone allocator, 1999 Andrea Arcangeli <andrea@suse.de> */
  8 
  9 #include <linux/pagemap.h>
 10 #include <linux/signal.h>
 11 #include <linux/sched.h>
 12 #include <linux/kernel.h>
 13 #include <linux/errno.h>
 14 #include <linux/string.h>
 15 #include <linux/types.h>
 16 #include <linux/ptrace.h>
 17 #include <linux/mman.h>
 18 #include <linux/mm.h>
 19 #include <linux/swap.h>
 20 #include <linux/init.h>
 21 #include <linux/bootmem.h> /* max_low_pfn */
 22 #include <linux/vmalloc.h>
 23 #include <linux/gfp.h>
 24 
 25 #include <asm/uaccess.h>
 26 #include <asm/pgtable.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 
 35 extern void die_if_kernel(char *,struct pt_regs *,long);
 36 
 37 static struct pcb_struct original_pcb;
 38 
 39 pgd_t *
 40 pgd_alloc(struct mm_struct *mm)
 41 {
 42         pgd_t *ret, *init;
 43 
 44         ret = (pgd_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
 45         init = pgd_offset(&init_mm, 0UL);
 46         if (ret) {
 47 #ifdef CONFIG_ALPHA_LARGE_VMALLOC
 48                 memcpy (ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
 49                         (PTRS_PER_PGD - USER_PTRS_PER_PGD - 1)*sizeof(pgd_t));
 50 #else
 51                 pgd_val(ret[PTRS_PER_PGD-2]) = pgd_val(init[PTRS_PER_PGD-2]);
 52 #endif
 53 
 54                 /* The last PGD entry is the VPTB self-map.  */
 55                 pgd_val(ret[PTRS_PER_PGD-1])
 56                   = pte_val(mk_pte(virt_to_page(ret), PAGE_KERNEL));
 57         }
 58         return ret;
 59 }
 60 
 61 
 62 /*
 63  * BAD_PAGE is the page that is used for page faults when linux
 64  * is out-of-memory. Older versions of linux just did a
 65  * do_exit(), but using this instead means there is less risk
 66  * for a process dying in kernel mode, possibly leaving an inode
 67  * unused etc..
 68  *
 69  * BAD_PAGETABLE is the accompanying page-table: it is initialized
 70  * to point to BAD_PAGE entries.
 71  *
 72  * ZERO_PAGE is a special page that is used for zero-initialized
 73  * data and COW.
 74  */
 75 pmd_t *
 76 __bad_pagetable(void)
 77 {
 78         memset((void *) EMPTY_PGT, 0, PAGE_SIZE);
 79         return (pmd_t *) EMPTY_PGT;
 80 }
 81 
 82 pte_t
 83 __bad_page(void)
 84 {
 85         memset((void *) EMPTY_PGE, 0, PAGE_SIZE);
 86         return pte_mkdirty(mk_pte(virt_to_page(EMPTY_PGE), PAGE_SHARED));
 87 }
 88 
 89 static inline unsigned long
 90 load_PCB(struct pcb_struct *pcb)
 91 {
 92         register unsigned long sp __asm__("$30");
 93         pcb->ksp = sp;
 94         return __reload_thread(pcb);
 95 }
 96 
 97 /* Set up initial PCB, VPTB, and other such nicities.  */
 98 
 99 static inline void
100 switch_to_system_map(void)
101 {
102         unsigned long newptbr;
103         unsigned long original_pcb_ptr;
104 
105         /* Initialize the kernel's page tables.  Linux puts the vptb in
106            the last slot of the L1 page table.  */
107         memset(swapper_pg_dir, 0, PAGE_SIZE);
108         newptbr = ((unsigned long) swapper_pg_dir - PAGE_OFFSET) >> PAGE_SHIFT;
109         pgd_val(swapper_pg_dir[1023]) =
110                 (newptbr << 32) | pgprot_val(PAGE_KERNEL);
111 
112         /* Set the vptb.  This is often done by the bootloader, but 
113            shouldn't be required.  */
114         if (hwrpb->vptb != 0xfffffffe00000000UL) {
115                 wrvptptr(0xfffffffe00000000UL);
116                 hwrpb->vptb = 0xfffffffe00000000UL;
117                 hwrpb_update_checksum(hwrpb);
118         }
119 
120         /* Also set up the real kernel PCB while we're at it.  */
121         init_thread_info.pcb.ptbr = newptbr;
122         init_thread_info.pcb.flags = 1; /* set FEN, clear everything else */
123         original_pcb_ptr = load_PCB(&init_thread_info.pcb);
124         tbia();
125 
126         /* Save off the contents of the original PCB so that we can
127            restore the original console's page tables for a clean reboot.
128 
129            Note that the PCB is supposed to be a physical address, but
130            since KSEG values also happen to work, folks get confused.
131            Check this here.  */
132 
133         if (original_pcb_ptr < PAGE_OFFSET) {
134                 original_pcb_ptr = (unsigned long)
135                         phys_to_virt(original_pcb_ptr);
136         }
137         original_pcb = *(struct pcb_struct *) original_pcb_ptr;
138 }
139 
140 int callback_init_done;
141 
142 void * __init
143 callback_init(void * kernel_end)
144 {
145         struct crb_struct * crb;
146         pgd_t *pgd;
147         pmd_t *pmd;
148         void *two_pages;
149 
150         /* Starting at the HWRPB, locate the CRB. */
151         crb = (struct crb_struct *)((char *)hwrpb + hwrpb->crb_offset);
152 
153         if (alpha_using_srm) {
154                 /* Tell the console whither it is to be remapped. */
155                 if (srm_fixup(VMALLOC_START, (unsigned long)hwrpb))
156                         __halt();               /* "We're boned."  --Bender */
157 
158                 /* Edit the procedure descriptors for DISPATCH and FIXUP. */
159                 crb->dispatch_va = (struct procdesc_struct *)
160                         (VMALLOC_START + (unsigned long)crb->dispatch_va
161                          - crb->map[0].va);
162                 crb->fixup_va = (struct procdesc_struct *)
163                         (VMALLOC_START + (unsigned long)crb->fixup_va
164                          - crb->map[0].va);
165         }
166 
167         switch_to_system_map();
168 
169         /* Allocate one PGD and one PMD.  In the case of SRM, we'll need
170            these to actually remap the console.  There is an assumption
171            here that only one of each is needed, and this allows for 8MB.
172            On systems with larger consoles, additional pages will be
173            allocated as needed during the mapping process.
174 
175            In the case of not SRM, but not CONFIG_ALPHA_LARGE_VMALLOC,
176            we need to allocate the PGD we use for vmalloc before we start
177            forking other tasks.  */
178 
179         two_pages = (void *)
180           (((unsigned long)kernel_end + ~PAGE_MASK) & PAGE_MASK);
181         kernel_end = two_pages + 2*PAGE_SIZE;
182         memset(two_pages, 0, 2*PAGE_SIZE);
183 
184         pgd = pgd_offset_k(VMALLOC_START);
185         pgd_set(pgd, (pmd_t *)two_pages);
186         pmd = pmd_offset(pgd, VMALLOC_START);
187         pmd_set(pmd, (pte_t *)(two_pages + PAGE_SIZE));
188 
189         if (alpha_using_srm) {
190                 static struct vm_struct console_remap_vm;
191                 unsigned long nr_pages = 0;
192                 unsigned long vaddr;
193                 unsigned long i, j;
194 
195                 /* calculate needed size */
196                 for (i = 0; i < crb->map_entries; ++i)
197                         nr_pages += crb->map[i].count;
198 
199                 /* register the vm area */
200                 console_remap_vm.flags = VM_ALLOC;
201                 console_remap_vm.size = nr_pages << PAGE_SHIFT;
202                 vm_area_register_early(&console_remap_vm, PAGE_SIZE);
203 
204                 vaddr = (unsigned long)console_remap_vm.addr;
205 
206                 /* Set up the third level PTEs and update the virtual
207                    addresses of the CRB entries.  */
208                 for (i = 0; i < crb->map_entries; ++i) {
209                         unsigned long pfn = crb->map[i].pa >> PAGE_SHIFT;
210                         crb->map[i].va = vaddr;
211                         for (j = 0; j < crb->map[i].count; ++j) {
212                                 /* Newer consoles (especially on larger
213                                    systems) may require more pages of
214                                    PTEs. Grab additional pages as needed. */
215                                 if (pmd != pmd_offset(pgd, vaddr)) {
216                                         memset(kernel_end, 0, PAGE_SIZE);
217                                         pmd = pmd_offset(pgd, vaddr);
218                                         pmd_set(pmd, (pte_t *)kernel_end);
219                                         kernel_end += PAGE_SIZE;
220                                 }
221                                 set_pte(pte_offset_kernel(pmd, vaddr),
222                                         pfn_pte(pfn, PAGE_KERNEL));
223                                 pfn++;
224                                 vaddr += PAGE_SIZE;
225                         }
226                 }
227         }
228 
229         callback_init_done = 1;
230         return kernel_end;
231 }
232 
233 
234 #ifndef CONFIG_DISCONTIGMEM
235 /*
236  * paging_init() sets up the memory map.
237  */
238 void __init paging_init(void)
239 {
240         unsigned long zones_size[MAX_NR_ZONES] = {0, };
241         unsigned long dma_pfn, high_pfn;
242 
243         dma_pfn = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
244         high_pfn = max_pfn = max_low_pfn;
245 
246         if (dma_pfn >= high_pfn)
247                 zones_size[ZONE_DMA] = high_pfn;
248         else {
249                 zones_size[ZONE_DMA] = dma_pfn;
250                 zones_size[ZONE_NORMAL] = high_pfn - dma_pfn;
251         }
252 
253         /* Initialize mem_map[].  */
254         free_area_init(zones_size);
255 
256         /* Initialize the kernel's ZERO_PGE. */
257         memset((void *)ZERO_PGE, 0, PAGE_SIZE);
258 }
259 #endif /* CONFIG_DISCONTIGMEM */
260 
261 #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM)
262 void
263 srm_paging_stop (void)
264 {
265         /* Move the vptb back to where the SRM console expects it.  */
266         swapper_pg_dir[1] = swapper_pg_dir[1023];
267         tbia();
268         wrvptptr(0x200000000UL);
269         hwrpb->vptb = 0x200000000UL;
270         hwrpb_update_checksum(hwrpb);
271 
272         /* Reload the page tables that the console had in use.  */
273         load_PCB(&original_pcb);
274         tbia();
275 }
276 #endif
277 
278 #ifndef CONFIG_DISCONTIGMEM
279 static void __init
280 printk_memory_info(void)
281 {
282         unsigned long codesize, reservedpages, datasize, initsize, tmp;
283         extern int page_is_ram(unsigned long) __init;
284         extern char _text, _etext, _data, _edata;
285         extern char __init_begin, __init_end;
286 
287         /* printk all informations */
288         reservedpages = 0;
289         for (tmp = 0; tmp < max_low_pfn; tmp++)
290                 /*
291                  * Only count reserved RAM pages
292                  */
293                 if (page_is_ram(tmp) && PageReserved(mem_map+tmp))
294                         reservedpages++;
295 
296         codesize =  (unsigned long) &_etext - (unsigned long) &_text;
297         datasize =  (unsigned long) &_edata - (unsigned long) &_data;
298         initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
299 
300         printk("Memory: %luk/%luk available (%luk kernel code, %luk reserved, %luk data, %luk init)\n",
301                nr_free_pages() << (PAGE_SHIFT-10),
302                max_mapnr << (PAGE_SHIFT-10),
303                codesize >> 10,
304                reservedpages << (PAGE_SHIFT-10),
305                datasize >> 10,
306                initsize >> 10);
307 }
308 
309 void __init
310 mem_init(void)
311 {
312         max_mapnr = num_physpages = max_low_pfn;
313         totalram_pages += free_all_bootmem();
314         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
315 
316         printk_memory_info();
317 }
318 #endif /* CONFIG_DISCONTIGMEM */
319 
320 void
321 free_reserved_mem(void *start, void *end)
322 {
323         void *__start = start;
324         for (; __start < end; __start += PAGE_SIZE) {
325                 ClearPageReserved(virt_to_page(__start));
326                 init_page_count(virt_to_page(__start));
327                 free_page((long)__start);
328                 totalram_pages++;
329         }
330 }
331 
332 void
333 free_initmem(void)
334 {
335         extern char __init_begin, __init_end;
336 
337         free_reserved_mem(&__init_begin, &__init_end);
338         printk ("Freeing unused kernel memory: %ldk freed\n",
339                 (&__init_end - &__init_begin) >> 10);
340 }
341 
342 #ifdef CONFIG_BLK_DEV_INITRD
343 void
344 free_initrd_mem(unsigned long start, unsigned long end)
345 {
346         free_reserved_mem((void *)start, (void *)end);
347         printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
348 }
349 #endif
350 

~ [ 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