xref: /linux/arch/s390/mm/init.c (revision 26b0d14106954ae46d2f4f7eec3481828a210f7d)
1 /*
2  *  arch/s390/mm/init.c
3  *
4  *  S390 version
5  *    Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
6  *    Author(s): Hartmut Penner (hp@de.ibm.com)
7  *
8  *  Derived from "arch/i386/mm/init.c"
9  *    Copyright (C) 1995  Linus Torvalds
10  */
11 
12 #include <linux/signal.h>
13 #include <linux/sched.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
17 #include <linux/types.h>
18 #include <linux/ptrace.h>
19 #include <linux/mman.h>
20 #include <linux/mm.h>
21 #include <linux/swap.h>
22 #include <linux/smp.h>
23 #include <linux/init.h>
24 #include <linux/pagemap.h>
25 #include <linux/bootmem.h>
26 #include <linux/pfn.h>
27 #include <linux/poison.h>
28 #include <linux/initrd.h>
29 #include <linux/export.h>
30 #include <linux/gfp.h>
31 #include <asm/processor.h>
32 #include <asm/uaccess.h>
33 #include <asm/pgtable.h>
34 #include <asm/pgalloc.h>
35 #include <asm/dma.h>
36 #include <asm/lowcore.h>
37 #include <asm/tlb.h>
38 #include <asm/tlbflush.h>
39 #include <asm/sections.h>
40 #include <asm/ctl_reg.h>
41 
42 pgd_t swapper_pg_dir[PTRS_PER_PGD] __attribute__((__aligned__(PAGE_SIZE)));
43 
44 unsigned long empty_zero_page, zero_page_mask;
45 EXPORT_SYMBOL(empty_zero_page);
46 
47 static unsigned long setup_zero_pages(void)
48 {
49 	struct cpuid cpu_id;
50 	unsigned int order;
51 	unsigned long size;
52 	struct page *page;
53 	int i;
54 
55 	get_cpu_id(&cpu_id);
56 	switch (cpu_id.machine) {
57 	case 0x9672:	/* g5 */
58 	case 0x2064:	/* z900 */
59 	case 0x2066:	/* z900 */
60 	case 0x2084:	/* z990 */
61 	case 0x2086:	/* z990 */
62 	case 0x2094:	/* z9-109 */
63 	case 0x2096:	/* z9-109 */
64 		order = 0;
65 		break;
66 	case 0x2097:	/* z10 */
67 	case 0x2098:	/* z10 */
68 	default:
69 		order = 2;
70 		break;
71 	}
72 
73 	empty_zero_page = __get_free_pages(GFP_KERNEL | __GFP_ZERO, order);
74 	if (!empty_zero_page)
75 		panic("Out of memory in setup_zero_pages");
76 
77 	page = virt_to_page((void *) empty_zero_page);
78 	split_page(page, order);
79 	for (i = 1 << order; i > 0; i--) {
80 		SetPageReserved(page);
81 		page++;
82 	}
83 
84 	size = PAGE_SIZE << order;
85 	zero_page_mask = (size - 1) & PAGE_MASK;
86 
87 	return 1UL << order;
88 }
89 
90 /*
91  * paging_init() sets up the page tables
92  */
93 void __init paging_init(void)
94 {
95 	unsigned long max_zone_pfns[MAX_NR_ZONES];
96 	unsigned long pgd_type, asce_bits;
97 
98 	init_mm.pgd = swapper_pg_dir;
99 #ifdef CONFIG_64BIT
100 	if (VMALLOC_END > (1UL << 42)) {
101 		asce_bits = _ASCE_TYPE_REGION2 | _ASCE_TABLE_LENGTH;
102 		pgd_type = _REGION2_ENTRY_EMPTY;
103 	} else {
104 		asce_bits = _ASCE_TYPE_REGION3 | _ASCE_TABLE_LENGTH;
105 		pgd_type = _REGION3_ENTRY_EMPTY;
106 	}
107 #else
108 	asce_bits = _ASCE_TABLE_LENGTH;
109 	pgd_type = _SEGMENT_ENTRY_EMPTY;
110 #endif
111 	S390_lowcore.kernel_asce = (__pa(init_mm.pgd) & PAGE_MASK) | asce_bits;
112 	clear_table((unsigned long *) init_mm.pgd, pgd_type,
113 		    sizeof(unsigned long)*2048);
114 	vmem_map_init();
115 
116         /* enable virtual mapping in kernel mode */
117 	__ctl_load(S390_lowcore.kernel_asce, 1, 1);
118 	__ctl_load(S390_lowcore.kernel_asce, 7, 7);
119 	__ctl_load(S390_lowcore.kernel_asce, 13, 13);
120 	arch_local_irq_restore(4UL << (BITS_PER_LONG - 8));
121 
122 	atomic_set(&init_mm.context.attach_count, 1);
123 
124 	sparse_memory_present_with_active_regions(MAX_NUMNODES);
125 	sparse_init();
126 	memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
127 	max_zone_pfns[ZONE_DMA] = PFN_DOWN(MAX_DMA_ADDRESS);
128 	max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
129 	free_area_init_nodes(max_zone_pfns);
130 	fault_init();
131 }
132 
133 void __init mem_init(void)
134 {
135 	unsigned long codesize, reservedpages, datasize, initsize;
136 
137         max_mapnr = num_physpages = max_low_pfn;
138         high_memory = (void *) __va(max_low_pfn * PAGE_SIZE);
139 
140 	/* Setup guest page hinting */
141 	cmma_init();
142 
143 	/* this will put all low memory onto the freelists */
144 	totalram_pages += free_all_bootmem();
145 	totalram_pages -= setup_zero_pages();	/* Setup zeroed pages. */
146 
147 	reservedpages = 0;
148 
149 	codesize =  (unsigned long) &_etext - (unsigned long) &_text;
150 	datasize =  (unsigned long) &_edata - (unsigned long) &_etext;
151 	initsize =  (unsigned long) &__init_end - (unsigned long) &__init_begin;
152         printk("Memory: %luk/%luk available (%ldk kernel code, %ldk reserved, %ldk data, %ldk init)\n",
153 		nr_free_pages() << (PAGE_SHIFT-10),
154                 max_mapnr << (PAGE_SHIFT-10),
155                 codesize >> 10,
156                 reservedpages << (PAGE_SHIFT-10),
157                 datasize >>10,
158                 initsize >> 10);
159 	printk("Write protected kernel read-only data: %#lx - %#lx\n",
160 	       (unsigned long)&_stext,
161 	       PFN_ALIGN((unsigned long)&_eshared) - 1);
162 }
163 
164 #ifdef CONFIG_DEBUG_PAGEALLOC
165 void kernel_map_pages(struct page *page, int numpages, int enable)
166 {
167 	pgd_t *pgd;
168 	pud_t *pud;
169 	pmd_t *pmd;
170 	pte_t *pte;
171 	unsigned long address;
172 	int i;
173 
174 	for (i = 0; i < numpages; i++) {
175 		address = page_to_phys(page + i);
176 		pgd = pgd_offset_k(address);
177 		pud = pud_offset(pgd, address);
178 		pmd = pmd_offset(pud, address);
179 		pte = pte_offset_kernel(pmd, address);
180 		if (!enable) {
181 			__ptep_ipte(address, pte);
182 			pte_val(*pte) = _PAGE_TYPE_EMPTY;
183 			continue;
184 		}
185 		*pte = mk_pte_phys(address, __pgprot(_PAGE_TYPE_RW));
186 		/* Flush cpu write queue. */
187 		mb();
188 	}
189 }
190 #endif
191 
192 void free_init_pages(char *what, unsigned long begin, unsigned long end)
193 {
194 	unsigned long addr = begin;
195 
196 	if (begin >= end)
197 		return;
198 	for (; addr < end; addr += PAGE_SIZE) {
199 		ClearPageReserved(virt_to_page(addr));
200 		init_page_count(virt_to_page(addr));
201 		memset((void *)(addr & PAGE_MASK), POISON_FREE_INITMEM,
202 		       PAGE_SIZE);
203 		free_page(addr);
204 		totalram_pages++;
205 	}
206 	printk(KERN_INFO "Freeing %s: %luk freed\n", what, (end - begin) >> 10);
207 }
208 
209 void free_initmem(void)
210 {
211 	free_init_pages("unused kernel memory",
212 			(unsigned long)&__init_begin,
213 			(unsigned long)&__init_end);
214 }
215 
216 #ifdef CONFIG_BLK_DEV_INITRD
217 void free_initrd_mem(unsigned long start, unsigned long end)
218 {
219 	free_init_pages("initrd memory", start, end);
220 }
221 #endif
222 
223 #ifdef CONFIG_MEMORY_HOTPLUG
224 int arch_add_memory(int nid, u64 start, u64 size)
225 {
226 	unsigned long zone_start_pfn, zone_end_pfn, nr_pages;
227 	unsigned long start_pfn = PFN_DOWN(start);
228 	unsigned long size_pages = PFN_DOWN(size);
229 	struct zone *zone;
230 	int rc;
231 
232 	rc = vmem_add_mapping(start, size);
233 	if (rc)
234 		return rc;
235 	for_each_zone(zone) {
236 		if (zone_idx(zone) != ZONE_MOVABLE) {
237 			/* Add range within existing zone limits */
238 			zone_start_pfn = zone->zone_start_pfn;
239 			zone_end_pfn = zone->zone_start_pfn +
240 				       zone->spanned_pages;
241 		} else {
242 			/* Add remaining range to ZONE_MOVABLE */
243 			zone_start_pfn = start_pfn;
244 			zone_end_pfn = start_pfn + size_pages;
245 		}
246 		if (start_pfn < zone_start_pfn || start_pfn >= zone_end_pfn)
247 			continue;
248 		nr_pages = (start_pfn + size_pages > zone_end_pfn) ?
249 			   zone_end_pfn - start_pfn : size_pages;
250 		rc = __add_pages(nid, zone, start_pfn, nr_pages);
251 		if (rc)
252 			break;
253 		start_pfn += nr_pages;
254 		size_pages -= nr_pages;
255 		if (!size_pages)
256 			break;
257 	}
258 	if (rc)
259 		vmem_remove_mapping(start, size);
260 	return rc;
261 }
262 #endif /* CONFIG_MEMORY_HOTPLUG */
263