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
24 #include <asm/system.h>
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
34 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
35
36 extern void die_if_kernel(char *,struct pt_regs *,long);
37
38 static struct pcb_struct original_pcb;
39
40 pgd_t *
pgd_alloc(struct mm_struct * mm)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 *
__bad_pagetable(void)77 __bad_pagetable(void)
78 {
79 memset((void *) EMPTY_PGT, 0, PAGE_SIZE);
80 return (pmd_t *) EMPTY_PGT;
81 }
82
83 pte_t
__bad_page(void)84 __bad_page(void)
85 {
86 memset((void *) 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
load_PCB(struct pcb_struct * pcb)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
switch_to_system_map(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
callback_init(void * kernel_end)144 callback_init(void * kernel_end)
145 {
146 struct crb_struct * crb;
147 pgd_t *pgd;
148 pmd_t *pmd;
149 void *two_pages;
150
151 /* Starting at the HWRPB, locate the CRB. */
152 crb = (struct crb_struct *)((char *)hwrpb + hwrpb->crb_offset);
153
154 if (alpha_using_srm) {
155 /* Tell the console whither it is to be remapped. */
156 if (srm_fixup(VMALLOC_START, (unsigned long)hwrpb))
157 __halt(); /* "We're boned." --Bender */
158
159 /* Edit the procedure descriptors for DISPATCH and FIXUP. */
160 crb->dispatch_va = (struct procdesc_struct *)
161 (VMALLOC_START + (unsigned long)crb->dispatch_va
162 - crb->map[0].va);
163 crb->fixup_va = (struct procdesc_struct *)
164 (VMALLOC_START + (unsigned long)crb->fixup_va
165 - crb->map[0].va);
166 }
167
168 switch_to_system_map();
169
170 /* Allocate one PGD and one PMD. In the case of SRM, we'll need
171 these to actually remap the console. There is an assumption
172 here that only one of each is needed, and this allows for 8MB.
173 On systems with larger consoles, additional pages will be
174 allocated as needed during the mapping process.
175
176 In the case of not SRM, but not CONFIG_ALPHA_LARGE_VMALLOC,
177 we need to allocate the PGD we use for vmalloc before we start
178 forking other tasks. */
179
180 two_pages = (void *)
181 (((unsigned long)kernel_end + ~PAGE_MASK) & PAGE_MASK);
182 kernel_end = two_pages + 2*PAGE_SIZE;
183 memset(two_pages, 0, 2*PAGE_SIZE);
184
185 pgd = pgd_offset_k(VMALLOC_START);
186 pgd_set(pgd, (pmd_t *)two_pages);
187 pmd = pmd_offset(pgd, VMALLOC_START);
188 pmd_set(pmd, (pte_t *)(two_pages + PAGE_SIZE));
189
190 if (alpha_using_srm) {
191 static struct vm_struct console_remap_vm;
192 unsigned long vaddr = VMALLOC_START;
193 unsigned long i, j;
194
195 /* Set up the third level PTEs and update the virtual
196 addresses of the CRB entries. */
197 for (i = 0; i < crb->map_entries; ++i) {
198 unsigned long pfn = crb->map[i].pa >> PAGE_SHIFT;
199 crb->map[i].va = vaddr;
200 for (j = 0; j < crb->map[i].count; ++j) {
201 /* Newer consoles (especially on larger
202 systems) may require more pages of
203 PTEs. Grab additional pages as needed. */
204 if (pmd != pmd_offset(pgd, vaddr)) {
205 memset(kernel_end, 0, PAGE_SIZE);
206 pmd = pmd_offset(pgd, vaddr);
207 pmd_set(pmd, (pte_t *)kernel_end);
208 kernel_end += PAGE_SIZE;
209 }
210 set_pte(pte_offset_kernel(pmd, vaddr),
211 pfn_pte(pfn, PAGE_KERNEL));
212 pfn++;
213 vaddr += PAGE_SIZE;
214 }
215 }
216
217 /* Let vmalloc know that we've allocated some space. */
218 console_remap_vm.flags = VM_ALLOC;
219 console_remap_vm.addr = (void *) VMALLOC_START;
220 console_remap_vm.size = vaddr - VMALLOC_START;
221 vmlist = &console_remap_vm;
222 }
223
224 callback_init_done = 1;
225 return kernel_end;
226 }
227
228
229 #ifndef CONFIG_DISCONTIGMEM
230 /*
231 * paging_init() sets up the memory map.
232 */
paging_init(void)233 void __init paging_init(void)
234 {
235 unsigned long zones_size[MAX_NR_ZONES] = {0, };
236 unsigned long dma_pfn, high_pfn;
237
238 dma_pfn = virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;
239 high_pfn = max_pfn = max_low_pfn;
240
241 if (dma_pfn >= high_pfn)
242 zones_size[ZONE_DMA] = high_pfn;
243 else {
244 zones_size[ZONE_DMA] = dma_pfn;
245 zones_size[ZONE_NORMAL] = high_pfn - dma_pfn;
246 }
247
248 /* Initialize mem_map[]. */
249 free_area_init(zones_size);
250
251 /* Initialize the kernel's ZERO_PGE. */
252 memset((void *)ZERO_PGE, 0, PAGE_SIZE);
253 }
254 #endif /* CONFIG_DISCONTIGMEM */
255
256 #if defined(CONFIG_ALPHA_GENERIC) || defined(CONFIG_ALPHA_SRM)
257 void
srm_paging_stop(void)258 srm_paging_stop (void)
259 {
260 /* Move the vptb back to where the SRM console expects it. */
261 swapper_pg_dir[1] = swapper_pg_dir[1023];
262 tbia();
263 wrvptptr(0x200000000UL);
264 hwrpb->vptb = 0x200000000UL;
265 hwrpb_update_checksum(hwrpb);
266
267 /* Reload the page tables that the console had in use. */
268 load_PCB(&original_pcb);
269 tbia();
270 }
271 #endif
272
273 #ifndef CONFIG_DISCONTIGMEM
274 static void __init
printk_memory_info(void)275 printk_memory_info(void)
276 {
277 unsigned long codesize, reservedpages, datasize, initsize, tmp;
278 extern int page_is_ram(unsigned long) __init;
279 extern char _text, _etext, _data, _edata;
280 extern char __init_begin, __init_end;
281
282 /* printk all informations */
283 reservedpages = 0;
284 for (tmp = 0; tmp < max_low_pfn; tmp++)
285 /*
286 * Only count reserved RAM pages
287 */
288 if (page_is_ram(tmp) && PageReserved(mem_map+tmp))
289 reservedpages++;
290
291 codesize = (unsigned long) &_etext - (unsigned long) &_text;
292 datasize = (unsigned long) &_edata - (unsigned long) &_data;
293 initsize = (unsigned long) &__init_end - (unsigned long) &__init_begin;
294
295 printk("Memory: %luk/%luk available (%luk kernel code, %luk reserved, %luk data, %luk init)\n",
296 (unsigned long) nr_free_pages() << (PAGE_SHIFT-10),
297 max_mapnr << (PAGE_SHIFT-10),
298 codesize >> 10,
299 reservedpages << (PAGE_SHIFT-10),
300 datasize >> 10,
301 initsize >> 10);
302 }
303
304 void __init
mem_init(void)305 mem_init(void)
306 {
307 max_mapnr = num_physpages = max_low_pfn;
308 totalram_pages += free_all_bootmem();
309 high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
310
311 printk_memory_info();
312 }
313 #endif /* CONFIG_DISCONTIGMEM */
314
315 void
free_reserved_mem(void * start,void * end)316 free_reserved_mem(void *start, void *end)
317 {
318 void *__start = start;
319 for (; __start < end; __start += PAGE_SIZE) {
320 ClearPageReserved(virt_to_page(__start));
321 init_page_count(virt_to_page(__start));
322 free_page((long)__start);
323 totalram_pages++;
324 }
325 }
326
327 void
free_initmem(void)328 free_initmem(void)
329 {
330 extern char __init_begin, __init_end;
331
332 free_reserved_mem(&__init_begin, &__init_end);
333 printk ("Freeing unused kernel memory: %ldk freed\n",
334 (&__init_end - &__init_begin) >> 10);
335 }
336
337 #ifdef CONFIG_BLK_DEV_INITRD
338 void
free_initrd_mem(unsigned long start,unsigned long end)339 free_initrd_mem(unsigned long start, unsigned long end)
340 {
341 free_reserved_mem((void *)start, (void *)end);
342 printk ("Freeing initrd memory: %ldk freed\n", (end - start) >> 10);
343 }
344 #endif
345