xref: /openbmc/linux/arch/arm64/mm/init.c (revision 323dd2c3)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Based on arch/arm/mm/init.c
4  *
5  * Copyright (C) 1995-2005 Russell King
6  * Copyright (C) 2012 ARM Ltd.
7  */
8 
9 #include <linux/kernel.h>
10 #include <linux/export.h>
11 #include <linux/errno.h>
12 #include <linux/swap.h>
13 #include <linux/init.h>
14 #include <linux/cache.h>
15 #include <linux/mman.h>
16 #include <linux/nodemask.h>
17 #include <linux/initrd.h>
18 #include <linux/gfp.h>
19 #include <linux/memblock.h>
20 #include <linux/sort.h>
21 #include <linux/of.h>
22 #include <linux/of_fdt.h>
23 #include <linux/dma-direct.h>
24 #include <linux/dma-mapping.h>
25 #include <linux/dma-contiguous.h>
26 #include <linux/efi.h>
27 #include <linux/swiotlb.h>
28 #include <linux/vmalloc.h>
29 #include <linux/mm.h>
30 #include <linux/kexec.h>
31 #include <linux/crash_dump.h>
32 
33 #include <asm/boot.h>
34 #include <asm/fixmap.h>
35 #include <asm/kasan.h>
36 #include <asm/kernel-pgtable.h>
37 #include <asm/memory.h>
38 #include <asm/numa.h>
39 #include <asm/sections.h>
40 #include <asm/setup.h>
41 #include <linux/sizes.h>
42 #include <asm/tlb.h>
43 #include <asm/alternative.h>
44 
45 #define ARM64_ZONE_DMA_BITS	30
46 
47 /*
48  * We need to be able to catch inadvertent references to memstart_addr
49  * that occur (potentially in generic code) before arm64_memblock_init()
50  * executes, which assigns it its actual value. So use a default value
51  * that cannot be mistaken for a real physical address.
52  */
53 s64 memstart_addr __ro_after_init = -1;
54 EXPORT_SYMBOL(memstart_addr);
55 
56 s64 physvirt_offset __ro_after_init;
57 EXPORT_SYMBOL(physvirt_offset);
58 
59 struct page *vmemmap __ro_after_init;
60 EXPORT_SYMBOL(vmemmap);
61 
62 /*
63  * We create both ZONE_DMA and ZONE_DMA32. ZONE_DMA covers the first 1G of
64  * memory as some devices, namely the Raspberry Pi 4, have peripherals with
65  * this limited view of the memory. ZONE_DMA32 will cover the rest of the 32
66  * bit addressable memory area.
67  */
68 phys_addr_t arm64_dma_phys_limit __ro_after_init;
69 static phys_addr_t arm64_dma32_phys_limit __ro_after_init;
70 
71 #ifdef CONFIG_KEXEC_CORE
72 /*
73  * reserve_crashkernel() - reserves memory for crash kernel
74  *
75  * This function reserves memory area given in "crashkernel=" kernel command
76  * line parameter. The memory reserved is used by dump capture kernel when
77  * primary kernel is crashing.
78  */
79 static void __init reserve_crashkernel(void)
80 {
81 	unsigned long long crash_base, crash_size;
82 	int ret;
83 
84 	ret = parse_crashkernel(boot_command_line, memblock_phys_mem_size(),
85 				&crash_size, &crash_base);
86 	/* no crashkernel= or invalid value specified */
87 	if (ret || !crash_size)
88 		return;
89 
90 	crash_size = PAGE_ALIGN(crash_size);
91 
92 	if (crash_base == 0) {
93 		/* Current arm64 boot protocol requires 2MB alignment */
94 		crash_base = memblock_find_in_range(0, arm64_dma32_phys_limit,
95 				crash_size, SZ_2M);
96 		if (crash_base == 0) {
97 			pr_warn("cannot allocate crashkernel (size:0x%llx)\n",
98 				crash_size);
99 			return;
100 		}
101 	} else {
102 		/* User specifies base address explicitly. */
103 		if (!memblock_is_region_memory(crash_base, crash_size)) {
104 			pr_warn("cannot reserve crashkernel: region is not memory\n");
105 			return;
106 		}
107 
108 		if (memblock_is_region_reserved(crash_base, crash_size)) {
109 			pr_warn("cannot reserve crashkernel: region overlaps reserved memory\n");
110 			return;
111 		}
112 
113 		if (!IS_ALIGNED(crash_base, SZ_2M)) {
114 			pr_warn("cannot reserve crashkernel: base address is not 2MB aligned\n");
115 			return;
116 		}
117 	}
118 	memblock_reserve(crash_base, crash_size);
119 
120 	pr_info("crashkernel reserved: 0x%016llx - 0x%016llx (%lld MB)\n",
121 		crash_base, crash_base + crash_size, crash_size >> 20);
122 
123 	crashk_res.start = crash_base;
124 	crashk_res.end = crash_base + crash_size - 1;
125 }
126 #else
127 static void __init reserve_crashkernel(void)
128 {
129 }
130 #endif /* CONFIG_KEXEC_CORE */
131 
132 #ifdef CONFIG_CRASH_DUMP
133 static int __init early_init_dt_scan_elfcorehdr(unsigned long node,
134 		const char *uname, int depth, void *data)
135 {
136 	const __be32 *reg;
137 	int len;
138 
139 	if (depth != 1 || strcmp(uname, "chosen") != 0)
140 		return 0;
141 
142 	reg = of_get_flat_dt_prop(node, "linux,elfcorehdr", &len);
143 	if (!reg || (len < (dt_root_addr_cells + dt_root_size_cells)))
144 		return 1;
145 
146 	elfcorehdr_addr = dt_mem_next_cell(dt_root_addr_cells, &reg);
147 	elfcorehdr_size = dt_mem_next_cell(dt_root_size_cells, &reg);
148 
149 	return 1;
150 }
151 
152 /*
153  * reserve_elfcorehdr() - reserves memory for elf core header
154  *
155  * This function reserves the memory occupied by an elf core header
156  * described in the device tree. This region contains all the
157  * information about primary kernel's core image and is used by a dump
158  * capture kernel to access the system memory on primary kernel.
159  */
160 static void __init reserve_elfcorehdr(void)
161 {
162 	of_scan_flat_dt(early_init_dt_scan_elfcorehdr, NULL);
163 
164 	if (!elfcorehdr_size)
165 		return;
166 
167 	if (memblock_is_region_reserved(elfcorehdr_addr, elfcorehdr_size)) {
168 		pr_warn("elfcorehdr is overlapped\n");
169 		return;
170 	}
171 
172 	memblock_reserve(elfcorehdr_addr, elfcorehdr_size);
173 
174 	pr_info("Reserving %lldKB of memory at 0x%llx for elfcorehdr\n",
175 		elfcorehdr_size >> 10, elfcorehdr_addr);
176 }
177 #else
178 static void __init reserve_elfcorehdr(void)
179 {
180 }
181 #endif /* CONFIG_CRASH_DUMP */
182 
183 /*
184  * Return the maximum physical address for a zone with a given address size
185  * limit. It currently assumes that for memory starting above 4G, 32-bit
186  * devices will use a DMA offset.
187  */
188 static phys_addr_t __init max_zone_phys(unsigned int zone_bits)
189 {
190 	phys_addr_t offset = memblock_start_of_DRAM() & GENMASK_ULL(63, zone_bits);
191 	return min(offset + (1ULL << zone_bits), memblock_end_of_DRAM());
192 }
193 
194 #ifdef CONFIG_NUMA
195 
196 static void __init zone_sizes_init(unsigned long min, unsigned long max)
197 {
198 	unsigned long max_zone_pfns[MAX_NR_ZONES]  = {0};
199 
200 #ifdef CONFIG_ZONE_DMA
201 	max_zone_pfns[ZONE_DMA] = PFN_DOWN(arm64_dma_phys_limit);
202 #endif
203 #ifdef CONFIG_ZONE_DMA32
204 	max_zone_pfns[ZONE_DMA32] = PFN_DOWN(arm64_dma32_phys_limit);
205 #endif
206 	max_zone_pfns[ZONE_NORMAL] = max;
207 
208 	free_area_init_nodes(max_zone_pfns);
209 }
210 
211 #else
212 
213 static void __init zone_sizes_init(unsigned long min, unsigned long max)
214 {
215 	struct memblock_region *reg;
216 	unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
217 	unsigned long max_dma32 = min;
218 	unsigned long __maybe_unused max_dma = min;
219 
220 	memset(zone_size, 0, sizeof(zone_size));
221 
222 #ifdef CONFIG_ZONE_DMA
223 	max_dma = PFN_DOWN(arm64_dma_phys_limit);
224 	zone_size[ZONE_DMA] = max_dma - min;
225 	max_dma32 = max_dma;
226 #endif
227 #ifdef CONFIG_ZONE_DMA32
228 	max_dma32 = PFN_DOWN(arm64_dma32_phys_limit);
229 	zone_size[ZONE_DMA32] = max_dma32 - max_dma;
230 #endif
231 	zone_size[ZONE_NORMAL] = max - max_dma32;
232 
233 	memcpy(zhole_size, zone_size, sizeof(zhole_size));
234 
235 	for_each_memblock(memory, reg) {
236 		unsigned long start = memblock_region_memory_base_pfn(reg);
237 		unsigned long end = memblock_region_memory_end_pfn(reg);
238 
239 		if (start >= max)
240 			continue;
241 #ifdef CONFIG_ZONE_DMA
242 		if (start < max_dma) {
243 			unsigned long dma_end = min_not_zero(end, max_dma);
244 			zhole_size[ZONE_DMA] -= dma_end - start;
245 		}
246 #endif
247 #ifdef CONFIG_ZONE_DMA32
248 		if (start < max_dma32) {
249 			unsigned long dma32_end = min(end, max_dma32);
250 			unsigned long dma32_start = max(start, max_dma);
251 			zhole_size[ZONE_DMA32] -= dma32_end - dma32_start;
252 		}
253 #endif
254 		if (end > max_dma32) {
255 			unsigned long normal_end = min(end, max);
256 			unsigned long normal_start = max(start, max_dma32);
257 			zhole_size[ZONE_NORMAL] -= normal_end - normal_start;
258 		}
259 	}
260 
261 	free_area_init_node(0, zone_size, min, zhole_size);
262 }
263 
264 #endif /* CONFIG_NUMA */
265 
266 int pfn_valid(unsigned long pfn)
267 {
268 	phys_addr_t addr = pfn << PAGE_SHIFT;
269 
270 	if ((addr >> PAGE_SHIFT) != pfn)
271 		return 0;
272 
273 #ifdef CONFIG_SPARSEMEM
274 	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
275 		return 0;
276 
277 	if (!valid_section(__nr_to_section(pfn_to_section_nr(pfn))))
278 		return 0;
279 #endif
280 	return memblock_is_map_memory(addr);
281 }
282 EXPORT_SYMBOL(pfn_valid);
283 
284 static phys_addr_t memory_limit = PHYS_ADDR_MAX;
285 
286 /*
287  * Limit the memory size that was specified via FDT.
288  */
289 static int __init early_mem(char *p)
290 {
291 	if (!p)
292 		return 1;
293 
294 	memory_limit = memparse(p, &p) & PAGE_MASK;
295 	pr_notice("Memory limited to %lldMB\n", memory_limit >> 20);
296 
297 	return 0;
298 }
299 early_param("mem", early_mem);
300 
301 static int __init early_init_dt_scan_usablemem(unsigned long node,
302 		const char *uname, int depth, void *data)
303 {
304 	struct memblock_region *usablemem = data;
305 	const __be32 *reg;
306 	int len;
307 
308 	if (depth != 1 || strcmp(uname, "chosen") != 0)
309 		return 0;
310 
311 	reg = of_get_flat_dt_prop(node, "linux,usable-memory-range", &len);
312 	if (!reg || (len < (dt_root_addr_cells + dt_root_size_cells)))
313 		return 1;
314 
315 	usablemem->base = dt_mem_next_cell(dt_root_addr_cells, &reg);
316 	usablemem->size = dt_mem_next_cell(dt_root_size_cells, &reg);
317 
318 	return 1;
319 }
320 
321 static void __init fdt_enforce_memory_region(void)
322 {
323 	struct memblock_region reg = {
324 		.size = 0,
325 	};
326 
327 	of_scan_flat_dt(early_init_dt_scan_usablemem, &reg);
328 
329 	if (reg.size)
330 		memblock_cap_memory_range(reg.base, reg.size);
331 }
332 
333 void __init arm64_memblock_init(void)
334 {
335 	const s64 linear_region_size = BIT(vabits_actual - 1);
336 
337 	/* Handle linux,usable-memory-range property */
338 	fdt_enforce_memory_region();
339 
340 	/* Remove memory above our supported physical address size */
341 	memblock_remove(1ULL << PHYS_MASK_SHIFT, ULLONG_MAX);
342 
343 	/*
344 	 * Select a suitable value for the base of physical memory.
345 	 */
346 	memstart_addr = round_down(memblock_start_of_DRAM(),
347 				   ARM64_MEMSTART_ALIGN);
348 
349 	physvirt_offset = PHYS_OFFSET - PAGE_OFFSET;
350 
351 	vmemmap = ((struct page *)VMEMMAP_START - (memstart_addr >> PAGE_SHIFT));
352 
353 	/*
354 	 * If we are running with a 52-bit kernel VA config on a system that
355 	 * does not support it, we have to offset our vmemmap and physvirt_offset
356 	 * s.t. we avoid the 52-bit portion of the direct linear map
357 	 */
358 	if (IS_ENABLED(CONFIG_ARM64_VA_BITS_52) && (vabits_actual != 52)) {
359 		vmemmap += (_PAGE_OFFSET(48) - _PAGE_OFFSET(52)) >> PAGE_SHIFT;
360 		physvirt_offset = PHYS_OFFSET - _PAGE_OFFSET(48);
361 	}
362 
363 	/*
364 	 * Remove the memory that we will not be able to cover with the
365 	 * linear mapping. Take care not to clip the kernel which may be
366 	 * high in memory.
367 	 */
368 	memblock_remove(max_t(u64, memstart_addr + linear_region_size,
369 			__pa_symbol(_end)), ULLONG_MAX);
370 	if (memstart_addr + linear_region_size < memblock_end_of_DRAM()) {
371 		/* ensure that memstart_addr remains sufficiently aligned */
372 		memstart_addr = round_up(memblock_end_of_DRAM() - linear_region_size,
373 					 ARM64_MEMSTART_ALIGN);
374 		memblock_remove(0, memstart_addr);
375 	}
376 
377 	/*
378 	 * Apply the memory limit if it was set. Since the kernel may be loaded
379 	 * high up in memory, add back the kernel region that must be accessible
380 	 * via the linear mapping.
381 	 */
382 	if (memory_limit != PHYS_ADDR_MAX) {
383 		memblock_mem_limit_remove_map(memory_limit);
384 		memblock_add(__pa_symbol(_text), (u64)(_end - _text));
385 	}
386 
387 	if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && phys_initrd_size) {
388 		/*
389 		 * Add back the memory we just removed if it results in the
390 		 * initrd to become inaccessible via the linear mapping.
391 		 * Otherwise, this is a no-op
392 		 */
393 		u64 base = phys_initrd_start & PAGE_MASK;
394 		u64 size = PAGE_ALIGN(phys_initrd_start + phys_initrd_size) - base;
395 
396 		/*
397 		 * We can only add back the initrd memory if we don't end up
398 		 * with more memory than we can address via the linear mapping.
399 		 * It is up to the bootloader to position the kernel and the
400 		 * initrd reasonably close to each other (i.e., within 32 GB of
401 		 * each other) so that all granule/#levels combinations can
402 		 * always access both.
403 		 */
404 		if (WARN(base < memblock_start_of_DRAM() ||
405 			 base + size > memblock_start_of_DRAM() +
406 				       linear_region_size,
407 			"initrd not fully accessible via the linear mapping -- please check your bootloader ...\n")) {
408 			phys_initrd_size = 0;
409 		} else {
410 			memblock_remove(base, size); /* clear MEMBLOCK_ flags */
411 			memblock_add(base, size);
412 			memblock_reserve(base, size);
413 		}
414 	}
415 
416 	if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
417 		extern u16 memstart_offset_seed;
418 		u64 range = linear_region_size -
419 			    (memblock_end_of_DRAM() - memblock_start_of_DRAM());
420 
421 		/*
422 		 * If the size of the linear region exceeds, by a sufficient
423 		 * margin, the size of the region that the available physical
424 		 * memory spans, randomize the linear region as well.
425 		 */
426 		if (memstart_offset_seed > 0 && range >= ARM64_MEMSTART_ALIGN) {
427 			range /= ARM64_MEMSTART_ALIGN;
428 			memstart_addr -= ARM64_MEMSTART_ALIGN *
429 					 ((range * memstart_offset_seed) >> 16);
430 		}
431 	}
432 
433 	/*
434 	 * Register the kernel text, kernel data, initrd, and initial
435 	 * pagetables with memblock.
436 	 */
437 	memblock_reserve(__pa_symbol(_text), _end - _text);
438 	if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && phys_initrd_size) {
439 		/* the generic initrd code expects virtual addresses */
440 		initrd_start = __phys_to_virt(phys_initrd_start);
441 		initrd_end = initrd_start + phys_initrd_size;
442 	}
443 
444 	early_init_fdt_scan_reserved_mem();
445 
446 	if (IS_ENABLED(CONFIG_ZONE_DMA)) {
447 		zone_dma_bits = ARM64_ZONE_DMA_BITS;
448 		arm64_dma_phys_limit = max_zone_phys(ARM64_ZONE_DMA_BITS);
449 	}
450 
451 	if (IS_ENABLED(CONFIG_ZONE_DMA32))
452 		arm64_dma32_phys_limit = max_zone_phys(32);
453 	else
454 		arm64_dma32_phys_limit = PHYS_MASK + 1;
455 
456 	reserve_crashkernel();
457 
458 	reserve_elfcorehdr();
459 
460 	high_memory = __va(memblock_end_of_DRAM() - 1) + 1;
461 
462 	dma_contiguous_reserve(arm64_dma32_phys_limit);
463 }
464 
465 void __init bootmem_init(void)
466 {
467 	unsigned long min, max;
468 
469 	min = PFN_UP(memblock_start_of_DRAM());
470 	max = PFN_DOWN(memblock_end_of_DRAM());
471 
472 	early_memtest(min << PAGE_SHIFT, max << PAGE_SHIFT);
473 
474 	max_pfn = max_low_pfn = max;
475 	min_low_pfn = min;
476 
477 	arm64_numa_init();
478 	/*
479 	 * Sparsemem tries to allocate bootmem in memory_present(), so must be
480 	 * done after the fixed reservations.
481 	 */
482 	memblocks_present();
483 
484 	sparse_init();
485 	zone_sizes_init(min, max);
486 
487 	memblock_dump_all();
488 }
489 
490 #ifndef CONFIG_SPARSEMEM_VMEMMAP
491 static inline void free_memmap(unsigned long start_pfn, unsigned long end_pfn)
492 {
493 	struct page *start_pg, *end_pg;
494 	unsigned long pg, pgend;
495 
496 	/*
497 	 * Convert start_pfn/end_pfn to a struct page pointer.
498 	 */
499 	start_pg = pfn_to_page(start_pfn - 1) + 1;
500 	end_pg = pfn_to_page(end_pfn - 1) + 1;
501 
502 	/*
503 	 * Convert to physical addresses, and round start upwards and end
504 	 * downwards.
505 	 */
506 	pg = (unsigned long)PAGE_ALIGN(__pa(start_pg));
507 	pgend = (unsigned long)__pa(end_pg) & PAGE_MASK;
508 
509 	/*
510 	 * If there are free pages between these, free the section of the
511 	 * memmap array.
512 	 */
513 	if (pg < pgend)
514 		memblock_free(pg, pgend - pg);
515 }
516 
517 /*
518  * The mem_map array can get very big. Free the unused area of the memory map.
519  */
520 static void __init free_unused_memmap(void)
521 {
522 	unsigned long start, prev_end = 0;
523 	struct memblock_region *reg;
524 
525 	for_each_memblock(memory, reg) {
526 		start = __phys_to_pfn(reg->base);
527 
528 #ifdef CONFIG_SPARSEMEM
529 		/*
530 		 * Take care not to free memmap entries that don't exist due
531 		 * to SPARSEMEM sections which aren't present.
532 		 */
533 		start = min(start, ALIGN(prev_end, PAGES_PER_SECTION));
534 #endif
535 		/*
536 		 * If we had a previous bank, and there is a space between the
537 		 * current bank and the previous, free it.
538 		 */
539 		if (prev_end && prev_end < start)
540 			free_memmap(prev_end, start);
541 
542 		/*
543 		 * Align up here since the VM subsystem insists that the
544 		 * memmap entries are valid from the bank end aligned to
545 		 * MAX_ORDER_NR_PAGES.
546 		 */
547 		prev_end = ALIGN(__phys_to_pfn(reg->base + reg->size),
548 				 MAX_ORDER_NR_PAGES);
549 	}
550 
551 #ifdef CONFIG_SPARSEMEM
552 	if (!IS_ALIGNED(prev_end, PAGES_PER_SECTION))
553 		free_memmap(prev_end, ALIGN(prev_end, PAGES_PER_SECTION));
554 #endif
555 }
556 #endif	/* !CONFIG_SPARSEMEM_VMEMMAP */
557 
558 /*
559  * mem_init() marks the free areas in the mem_map and tells us how much memory
560  * is free.  This is done after various parts of the system have claimed their
561  * memory after the kernel image.
562  */
563 void __init mem_init(void)
564 {
565 	if (swiotlb_force == SWIOTLB_FORCE ||
566 	    max_pfn > PFN_DOWN(arm64_dma_phys_limit ? : arm64_dma32_phys_limit))
567 		swiotlb_init(1);
568 	else
569 		swiotlb_force = SWIOTLB_NO_FORCE;
570 
571 	set_max_mapnr(max_pfn - PHYS_PFN_OFFSET);
572 
573 #ifndef CONFIG_SPARSEMEM_VMEMMAP
574 	free_unused_memmap();
575 #endif
576 	/* this will put all unused low memory onto the freelists */
577 	memblock_free_all();
578 
579 	mem_init_print_info(NULL);
580 
581 	/*
582 	 * Check boundaries twice: Some fundamental inconsistencies can be
583 	 * detected at build time already.
584 	 */
585 #ifdef CONFIG_COMPAT
586 	BUILD_BUG_ON(TASK_SIZE_32 > DEFAULT_MAP_WINDOW_64);
587 #endif
588 
589 	if (PAGE_SIZE >= 16384 && get_num_physpages() <= 128) {
590 		extern int sysctl_overcommit_memory;
591 		/*
592 		 * On a machine this small we won't get anywhere without
593 		 * overcommit, so turn it on by default.
594 		 */
595 		sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
596 	}
597 }
598 
599 void free_initmem(void)
600 {
601 	free_reserved_area(lm_alias(__init_begin),
602 			   lm_alias(__init_end),
603 			   POISON_FREE_INITMEM, "unused kernel");
604 	/*
605 	 * Unmap the __init region but leave the VM area in place. This
606 	 * prevents the region from being reused for kernel modules, which
607 	 * is not supported by kallsyms.
608 	 */
609 	unmap_kernel_range((u64)__init_begin, (u64)(__init_end - __init_begin));
610 }
611 
612 /*
613  * Dump out memory limit information on panic.
614  */
615 static int dump_mem_limit(struct notifier_block *self, unsigned long v, void *p)
616 {
617 	if (memory_limit != PHYS_ADDR_MAX) {
618 		pr_emerg("Memory Limit: %llu MB\n", memory_limit >> 20);
619 	} else {
620 		pr_emerg("Memory Limit: none\n");
621 	}
622 	return 0;
623 }
624 
625 static struct notifier_block mem_limit_notifier = {
626 	.notifier_call = dump_mem_limit,
627 };
628 
629 static int __init register_mem_limit_dumper(void)
630 {
631 	atomic_notifier_chain_register(&panic_notifier_list,
632 				       &mem_limit_notifier);
633 	return 0;
634 }
635 __initcall(register_mem_limit_dumper);
636