xref: /openbmc/linux/arch/s390/kernel/setup.c (revision 9322af3e6aeae04c7eda3e6a0c977e97a13cf6ed)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  S390 version
4  *    Copyright IBM Corp. 1999, 2012
5  *    Author(s): Hartmut Penner (hp@de.ibm.com),
6  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
7  *
8  *  Derived from "arch/i386/kernel/setup.c"
9  *    Copyright (C) 1995, Linus Torvalds
10  */
11 
12 /*
13  * This file handles the architecture-dependent parts of initialization
14  */
15 
16 #define KMSG_COMPONENT "setup"
17 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
18 
19 #include <linux/errno.h>
20 #include <linux/export.h>
21 #include <linux/sched.h>
22 #include <linux/sched/task.h>
23 #include <linux/cpu.h>
24 #include <linux/kernel.h>
25 #include <linux/memblock.h>
26 #include <linux/mm.h>
27 #include <linux/stddef.h>
28 #include <linux/unistd.h>
29 #include <linux/ptrace.h>
30 #include <linux/random.h>
31 #include <linux/user.h>
32 #include <linux/tty.h>
33 #include <linux/ioport.h>
34 #include <linux/delay.h>
35 #include <linux/init.h>
36 #include <linux/initrd.h>
37 #include <linux/root_dev.h>
38 #include <linux/console.h>
39 #include <linux/kernel_stat.h>
40 #include <linux/dma-map-ops.h>
41 #include <linux/device.h>
42 #include <linux/notifier.h>
43 #include <linux/pfn.h>
44 #include <linux/ctype.h>
45 #include <linux/reboot.h>
46 #include <linux/topology.h>
47 #include <linux/kexec.h>
48 #include <linux/crash_dump.h>
49 #include <linux/memory.h>
50 #include <linux/compat.h>
51 #include <linux/start_kernel.h>
52 #include <linux/hugetlb.h>
53 #include <linux/kmemleak.h>
54 
55 #include <asm/boot_data.h>
56 #include <asm/ipl.h>
57 #include <asm/facility.h>
58 #include <asm/smp.h>
59 #include <asm/mmu_context.h>
60 #include <asm/cpcmd.h>
61 #include <asm/abs_lowcore.h>
62 #include <asm/nmi.h>
63 #include <asm/irq.h>
64 #include <asm/page.h>
65 #include <asm/ptrace.h>
66 #include <asm/sections.h>
67 #include <asm/ebcdic.h>
68 #include <asm/diag.h>
69 #include <asm/os_info.h>
70 #include <asm/sclp.h>
71 #include <asm/stacktrace.h>
72 #include <asm/sysinfo.h>
73 #include <asm/numa.h>
74 #include <asm/alternative.h>
75 #include <asm/nospec-branch.h>
76 #include <asm/mem_detect.h>
77 #include <asm/maccess.h>
78 #include <asm/uv.h>
79 #include <asm/asm-offsets.h>
80 #include "entry.h"
81 
82 /*
83  * Machine setup..
84  */
85 unsigned int console_mode = 0;
86 EXPORT_SYMBOL(console_mode);
87 
88 unsigned int console_devno = -1;
89 EXPORT_SYMBOL(console_devno);
90 
91 unsigned int console_irq = -1;
92 EXPORT_SYMBOL(console_irq);
93 
94 /*
95  * Some code and data needs to stay below 2 GB, even when the kernel would be
96  * relocated above 2 GB, because it has to use 31 bit addresses.
97  * Such code and data is part of the .amode31 section.
98  */
99 unsigned long __amode31_ref __samode31 = (unsigned long)&_samode31;
100 unsigned long __amode31_ref __eamode31 = (unsigned long)&_eamode31;
101 unsigned long __amode31_ref __stext_amode31 = (unsigned long)&_stext_amode31;
102 unsigned long __amode31_ref __etext_amode31 = (unsigned long)&_etext_amode31;
103 struct exception_table_entry __amode31_ref *__start_amode31_ex_table = _start_amode31_ex_table;
104 struct exception_table_entry __amode31_ref *__stop_amode31_ex_table = _stop_amode31_ex_table;
105 
106 /*
107  * Control registers CR2, CR5 and CR15 are initialized with addresses
108  * of tables that must be placed below 2G which is handled by the AMODE31
109  * sections.
110  * Because the AMODE31 sections are relocated below 2G at startup,
111  * the content of control registers CR2, CR5 and CR15 must be updated
112  * with new addresses after the relocation. The initial initialization of
113  * control registers occurs in head64.S and then gets updated again after AMODE31
114  * relocation. We must access the relevant AMODE31 tables indirectly via
115  * pointers placed in the .amode31.refs linker section. Those pointers get
116  * updated automatically during AMODE31 relocation and always contain a valid
117  * address within AMODE31 sections.
118  */
119 
120 static __amode31_data u32 __ctl_duct_amode31[16] __aligned(64);
121 
122 static __amode31_data u64 __ctl_aste_amode31[8] __aligned(64) = {
123 	[1] = 0xffffffffffffffff
124 };
125 
126 static __amode31_data u32 __ctl_duald_amode31[32] __aligned(128) = {
127 	0x80000000, 0, 0, 0,
128 	0x80000000, 0, 0, 0,
129 	0x80000000, 0, 0, 0,
130 	0x80000000, 0, 0, 0,
131 	0x80000000, 0, 0, 0,
132 	0x80000000, 0, 0, 0,
133 	0x80000000, 0, 0, 0,
134 	0x80000000, 0, 0, 0
135 };
136 
137 static __amode31_data u32 __ctl_linkage_stack_amode31[8] __aligned(64) = {
138 	0, 0, 0x89000000, 0,
139 	0, 0, 0x8a000000, 0
140 };
141 
142 static u64 __amode31_ref *__ctl_aste = __ctl_aste_amode31;
143 static u32 __amode31_ref *__ctl_duald = __ctl_duald_amode31;
144 static u32 __amode31_ref *__ctl_linkage_stack = __ctl_linkage_stack_amode31;
145 static u32 __amode31_ref *__ctl_duct = __ctl_duct_amode31;
146 
147 int __bootdata(noexec_disabled);
148 unsigned long __bootdata(ident_map_size);
149 struct mem_detect_info __bootdata(mem_detect);
150 struct initrd_data __bootdata(initrd_data);
151 
152 unsigned long __bootdata_preserved(__kaslr_offset);
153 unsigned long __bootdata(__amode31_base);
154 unsigned int __bootdata_preserved(zlib_dfltcc_support);
155 EXPORT_SYMBOL(zlib_dfltcc_support);
156 u64 __bootdata_preserved(stfle_fac_list[16]);
157 EXPORT_SYMBOL(stfle_fac_list);
158 u64 __bootdata_preserved(alt_stfle_fac_list[16]);
159 struct oldmem_data __bootdata_preserved(oldmem_data);
160 
161 unsigned long VMALLOC_START;
162 EXPORT_SYMBOL(VMALLOC_START);
163 
164 unsigned long VMALLOC_END;
165 EXPORT_SYMBOL(VMALLOC_END);
166 
167 struct page *vmemmap;
168 EXPORT_SYMBOL(vmemmap);
169 unsigned long vmemmap_size;
170 
171 unsigned long MODULES_VADDR;
172 unsigned long MODULES_END;
173 
174 /* An array with a pointer to the lowcore of every CPU. */
175 struct lowcore *lowcore_ptr[NR_CPUS];
176 EXPORT_SYMBOL(lowcore_ptr);
177 
178 DEFINE_STATIC_KEY_FALSE(cpu_has_bear);
179 
180 /*
181  * The Write Back bit position in the physaddr is given by the SLPC PCI.
182  * Leaving the mask zero always uses write through which is safe
183  */
184 unsigned long mio_wb_bit_mask __ro_after_init;
185 
186 /*
187  * This is set up by the setup-routine at boot-time
188  * for S390 need to find out, what we have to setup
189  * using address 0x10400 ...
190  */
191 
192 #include <asm/setup.h>
193 
194 /*
195  * condev= and conmode= setup parameter.
196  */
197 
198 static int __init condev_setup(char *str)
199 {
200 	int vdev;
201 
202 	vdev = simple_strtoul(str, &str, 0);
203 	if (vdev >= 0 && vdev < 65536) {
204 		console_devno = vdev;
205 		console_irq = -1;
206 	}
207 	return 1;
208 }
209 
210 __setup("condev=", condev_setup);
211 
212 static void __init set_preferred_console(void)
213 {
214 	if (CONSOLE_IS_3215 || CONSOLE_IS_SCLP)
215 		add_preferred_console("ttyS", 0, NULL);
216 	else if (CONSOLE_IS_3270)
217 		add_preferred_console("tty3270", 0, NULL);
218 	else if (CONSOLE_IS_VT220)
219 		add_preferred_console("ttysclp", 0, NULL);
220 	else if (CONSOLE_IS_HVC)
221 		add_preferred_console("hvc", 0, NULL);
222 }
223 
224 static int __init conmode_setup(char *str)
225 {
226 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
227 	if (!strcmp(str, "hwc") || !strcmp(str, "sclp"))
228                 SET_CONSOLE_SCLP;
229 #endif
230 #if defined(CONFIG_TN3215_CONSOLE)
231 	if (!strcmp(str, "3215"))
232 		SET_CONSOLE_3215;
233 #endif
234 #if defined(CONFIG_TN3270_CONSOLE)
235 	if (!strcmp(str, "3270"))
236 		SET_CONSOLE_3270;
237 #endif
238 	set_preferred_console();
239         return 1;
240 }
241 
242 __setup("conmode=", conmode_setup);
243 
244 static void __init conmode_default(void)
245 {
246 	char query_buffer[1024];
247 	char *ptr;
248 
249         if (MACHINE_IS_VM) {
250 		cpcmd("QUERY CONSOLE", query_buffer, 1024, NULL);
251 		console_devno = simple_strtoul(query_buffer + 5, NULL, 16);
252 		ptr = strstr(query_buffer, "SUBCHANNEL =");
253 		console_irq = simple_strtoul(ptr + 13, NULL, 16);
254 		cpcmd("QUERY TERM", query_buffer, 1024, NULL);
255 		ptr = strstr(query_buffer, "CONMODE");
256 		/*
257 		 * Set the conmode to 3215 so that the device recognition
258 		 * will set the cu_type of the console to 3215. If the
259 		 * conmode is 3270 and we don't set it back then both
260 		 * 3215 and the 3270 driver will try to access the console
261 		 * device (3215 as console and 3270 as normal tty).
262 		 */
263 		cpcmd("TERM CONMODE 3215", NULL, 0, NULL);
264 		if (ptr == NULL) {
265 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
266 			SET_CONSOLE_SCLP;
267 #endif
268 			return;
269 		}
270 		if (str_has_prefix(ptr + 8, "3270")) {
271 #if defined(CONFIG_TN3270_CONSOLE)
272 			SET_CONSOLE_3270;
273 #elif defined(CONFIG_TN3215_CONSOLE)
274 			SET_CONSOLE_3215;
275 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
276 			SET_CONSOLE_SCLP;
277 #endif
278 		} else if (str_has_prefix(ptr + 8, "3215")) {
279 #if defined(CONFIG_TN3215_CONSOLE)
280 			SET_CONSOLE_3215;
281 #elif defined(CONFIG_TN3270_CONSOLE)
282 			SET_CONSOLE_3270;
283 #elif defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
284 			SET_CONSOLE_SCLP;
285 #endif
286 		}
287 	} else if (MACHINE_IS_KVM) {
288 		if (sclp.has_vt220 && IS_ENABLED(CONFIG_SCLP_VT220_CONSOLE))
289 			SET_CONSOLE_VT220;
290 		else if (sclp.has_linemode && IS_ENABLED(CONFIG_SCLP_CONSOLE))
291 			SET_CONSOLE_SCLP;
292 		else
293 			SET_CONSOLE_HVC;
294 	} else {
295 #if defined(CONFIG_SCLP_CONSOLE) || defined(CONFIG_SCLP_VT220_CONSOLE)
296 		SET_CONSOLE_SCLP;
297 #endif
298 	}
299 }
300 
301 #ifdef CONFIG_CRASH_DUMP
302 static void __init setup_zfcpdump(void)
303 {
304 	if (!is_ipl_type_dump())
305 		return;
306 	if (oldmem_data.start)
307 		return;
308 	strcat(boot_command_line, " cio_ignore=all,!ipldev,!condev");
309 	console_loglevel = 2;
310 }
311 #else
312 static inline void setup_zfcpdump(void) {}
313 #endif /* CONFIG_CRASH_DUMP */
314 
315  /*
316  * Reboot, halt and power_off stubs. They just call _machine_restart,
317  * _machine_halt or _machine_power_off.
318  */
319 
320 void machine_restart(char *command)
321 {
322 	if ((!in_interrupt() && !in_atomic()) || oops_in_progress)
323 		/*
324 		 * Only unblank the console if we are called in enabled
325 		 * context or a bust_spinlocks cleared the way for us.
326 		 */
327 		console_unblank();
328 	_machine_restart(command);
329 }
330 
331 void machine_halt(void)
332 {
333 	if (!in_interrupt() || oops_in_progress)
334 		/*
335 		 * Only unblank the console if we are called in enabled
336 		 * context or a bust_spinlocks cleared the way for us.
337 		 */
338 		console_unblank();
339 	_machine_halt();
340 }
341 
342 void machine_power_off(void)
343 {
344 	if (!in_interrupt() || oops_in_progress)
345 		/*
346 		 * Only unblank the console if we are called in enabled
347 		 * context or a bust_spinlocks cleared the way for us.
348 		 */
349 		console_unblank();
350 	_machine_power_off();
351 }
352 
353 /*
354  * Dummy power off function.
355  */
356 void (*pm_power_off)(void) = machine_power_off;
357 EXPORT_SYMBOL_GPL(pm_power_off);
358 
359 void *restart_stack;
360 
361 unsigned long stack_alloc(void)
362 {
363 #ifdef CONFIG_VMAP_STACK
364 	void *ret;
365 
366 	ret = __vmalloc_node(THREAD_SIZE, THREAD_SIZE, THREADINFO_GFP,
367 			     NUMA_NO_NODE, __builtin_return_address(0));
368 	kmemleak_not_leak(ret);
369 	return (unsigned long)ret;
370 #else
371 	return __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER);
372 #endif
373 }
374 
375 void stack_free(unsigned long stack)
376 {
377 #ifdef CONFIG_VMAP_STACK
378 	vfree((void *) stack);
379 #else
380 	free_pages(stack, THREAD_SIZE_ORDER);
381 #endif
382 }
383 
384 int __init arch_early_irq_init(void)
385 {
386 	unsigned long stack;
387 
388 	stack = __get_free_pages(GFP_KERNEL, THREAD_SIZE_ORDER);
389 	if (!stack)
390 		panic("Couldn't allocate async stack");
391 	S390_lowcore.async_stack = stack + STACK_INIT_OFFSET;
392 	return 0;
393 }
394 
395 void __init arch_call_rest_init(void)
396 {
397 	unsigned long stack;
398 
399 	smp_reinit_ipl_cpu();
400 	stack = stack_alloc();
401 	if (!stack)
402 		panic("Couldn't allocate kernel stack");
403 	current->stack = (void *) stack;
404 #ifdef CONFIG_VMAP_STACK
405 	current->stack_vm_area = (void *) stack;
406 #endif
407 	set_task_stack_end_magic(current);
408 	stack += STACK_INIT_OFFSET;
409 	S390_lowcore.kernel_stack = stack;
410 	call_on_stack_noreturn(rest_init, stack);
411 }
412 
413 static void __init setup_lowcore_dat_off(void)
414 {
415 	unsigned long int_psw_mask = PSW_KERNEL_BITS;
416 	struct lowcore *abs_lc, *lc;
417 	unsigned long mcck_stack;
418 	unsigned long flags;
419 
420 	if (IS_ENABLED(CONFIG_KASAN))
421 		int_psw_mask |= PSW_MASK_DAT;
422 
423 	/*
424 	 * Setup lowcore for boot cpu
425 	 */
426 	BUILD_BUG_ON(sizeof(struct lowcore) != LC_PAGES * PAGE_SIZE);
427 	lc = memblock_alloc_low(sizeof(*lc), sizeof(*lc));
428 	if (!lc)
429 		panic("%s: Failed to allocate %zu bytes align=%zx\n",
430 		      __func__, sizeof(*lc), sizeof(*lc));
431 
432 	lc->restart_psw.mask = PSW_KERNEL_BITS;
433 	lc->restart_psw.addr = (unsigned long) restart_int_handler;
434 	lc->external_new_psw.mask = int_psw_mask | PSW_MASK_MCHECK;
435 	lc->external_new_psw.addr = (unsigned long) ext_int_handler;
436 	lc->svc_new_psw.mask = int_psw_mask | PSW_MASK_MCHECK;
437 	lc->svc_new_psw.addr = (unsigned long) system_call;
438 	lc->program_new_psw.mask = int_psw_mask | PSW_MASK_MCHECK;
439 	lc->program_new_psw.addr = (unsigned long) pgm_check_handler;
440 	lc->mcck_new_psw.mask = int_psw_mask;
441 	lc->mcck_new_psw.addr = (unsigned long) mcck_int_handler;
442 	lc->io_new_psw.mask = int_psw_mask | PSW_MASK_MCHECK;
443 	lc->io_new_psw.addr = (unsigned long) io_int_handler;
444 	lc->clock_comparator = clock_comparator_max;
445 	lc->nodat_stack = ((unsigned long) &init_thread_union)
446 		+ THREAD_SIZE - STACK_FRAME_OVERHEAD - sizeof(struct pt_regs);
447 	lc->current_task = (unsigned long)&init_task;
448 	lc->lpp = LPP_MAGIC;
449 	lc->machine_flags = S390_lowcore.machine_flags;
450 	lc->preempt_count = S390_lowcore.preempt_count;
451 	nmi_alloc_mcesa_early(&lc->mcesad);
452 	lc->sys_enter_timer = S390_lowcore.sys_enter_timer;
453 	lc->exit_timer = S390_lowcore.exit_timer;
454 	lc->user_timer = S390_lowcore.user_timer;
455 	lc->system_timer = S390_lowcore.system_timer;
456 	lc->steal_timer = S390_lowcore.steal_timer;
457 	lc->last_update_timer = S390_lowcore.last_update_timer;
458 	lc->last_update_clock = S390_lowcore.last_update_clock;
459 
460 	/*
461 	 * Allocate the global restart stack which is the same for
462 	 * all CPUs in cast *one* of them does a PSW restart.
463 	 */
464 	restart_stack = memblock_alloc(THREAD_SIZE, THREAD_SIZE);
465 	if (!restart_stack)
466 		panic("%s: Failed to allocate %lu bytes align=0x%lx\n",
467 		      __func__, THREAD_SIZE, THREAD_SIZE);
468 	restart_stack += STACK_INIT_OFFSET;
469 
470 	/*
471 	 * Set up PSW restart to call ipl.c:do_restart(). Copy the relevant
472 	 * restart data to the absolute zero lowcore. This is necessary if
473 	 * PSW restart is done on an offline CPU that has lowcore zero.
474 	 */
475 	lc->restart_stack = (unsigned long) restart_stack;
476 	lc->restart_fn = (unsigned long) do_restart;
477 	lc->restart_data = 0;
478 	lc->restart_source = -1U;
479 
480 	abs_lc = get_abs_lowcore(&flags);
481 	abs_lc->restart_stack = lc->restart_stack;
482 	abs_lc->restart_fn = lc->restart_fn;
483 	abs_lc->restart_data = lc->restart_data;
484 	abs_lc->restart_source = lc->restart_source;
485 	abs_lc->restart_psw = lc->restart_psw;
486 	abs_lc->mcesad = lc->mcesad;
487 	put_abs_lowcore(abs_lc, flags);
488 
489 	mcck_stack = (unsigned long)memblock_alloc(THREAD_SIZE, THREAD_SIZE);
490 	if (!mcck_stack)
491 		panic("%s: Failed to allocate %lu bytes align=0x%lx\n",
492 		      __func__, THREAD_SIZE, THREAD_SIZE);
493 	lc->mcck_stack = mcck_stack + STACK_INIT_OFFSET;
494 
495 	lc->spinlock_lockval = arch_spin_lockval(0);
496 	lc->spinlock_index = 0;
497 	arch_spin_lock_setup(0);
498 	lc->return_lpswe = gen_lpswe(__LC_RETURN_PSW);
499 	lc->return_mcck_lpswe = gen_lpswe(__LC_RETURN_MCCK_PSW);
500 	lc->preempt_count = PREEMPT_DISABLED;
501 
502 	set_prefix(__pa(lc));
503 	lowcore_ptr[0] = lc;
504 }
505 
506 static void __init setup_lowcore_dat_on(void)
507 {
508 	struct lowcore *abs_lc;
509 	unsigned long flags;
510 
511 	__ctl_clear_bit(0, 28);
512 	S390_lowcore.external_new_psw.mask |= PSW_MASK_DAT;
513 	S390_lowcore.svc_new_psw.mask |= PSW_MASK_DAT;
514 	S390_lowcore.program_new_psw.mask |= PSW_MASK_DAT;
515 	S390_lowcore.mcck_new_psw.mask |= PSW_MASK_DAT;
516 	S390_lowcore.io_new_psw.mask |= PSW_MASK_DAT;
517 	__ctl_set_bit(0, 28);
518 	__ctl_store(S390_lowcore.cregs_save_area, 0, 15);
519 	if (abs_lowcore_map(0, lowcore_ptr[0], true))
520 		panic("Couldn't setup absolute lowcore");
521 	abs_lowcore_mapped = true;
522 	abs_lc = get_abs_lowcore(&flags);
523 	abs_lc->restart_flags = RESTART_FLAG_CTLREGS;
524 	abs_lc->program_new_psw = S390_lowcore.program_new_psw;
525 	memcpy(abs_lc->cregs_save_area, S390_lowcore.cregs_save_area,
526 	       sizeof(abs_lc->cregs_save_area));
527 	put_abs_lowcore(abs_lc, flags);
528 }
529 
530 static struct resource code_resource = {
531 	.name  = "Kernel code",
532 	.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
533 };
534 
535 static struct resource data_resource = {
536 	.name = "Kernel data",
537 	.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
538 };
539 
540 static struct resource bss_resource = {
541 	.name = "Kernel bss",
542 	.flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
543 };
544 
545 static struct resource __initdata *standard_resources[] = {
546 	&code_resource,
547 	&data_resource,
548 	&bss_resource,
549 };
550 
551 static void __init setup_resources(void)
552 {
553 	struct resource *res, *std_res, *sub_res;
554 	phys_addr_t start, end;
555 	int j;
556 	u64 i;
557 
558 	code_resource.start = (unsigned long) _text;
559 	code_resource.end = (unsigned long) _etext - 1;
560 	data_resource.start = (unsigned long) _etext;
561 	data_resource.end = (unsigned long) _edata - 1;
562 	bss_resource.start = (unsigned long) __bss_start;
563 	bss_resource.end = (unsigned long) __bss_stop - 1;
564 
565 	for_each_mem_range(i, &start, &end) {
566 		res = memblock_alloc(sizeof(*res), 8);
567 		if (!res)
568 			panic("%s: Failed to allocate %zu bytes align=0x%x\n",
569 			      __func__, sizeof(*res), 8);
570 		res->flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM;
571 
572 		res->name = "System RAM";
573 		res->start = start;
574 		/*
575 		 * In memblock, end points to the first byte after the
576 		 * range while in resourses, end points to the last byte in
577 		 * the range.
578 		 */
579 		res->end = end - 1;
580 		request_resource(&iomem_resource, res);
581 
582 		for (j = 0; j < ARRAY_SIZE(standard_resources); j++) {
583 			std_res = standard_resources[j];
584 			if (std_res->start < res->start ||
585 			    std_res->start > res->end)
586 				continue;
587 			if (std_res->end > res->end) {
588 				sub_res = memblock_alloc(sizeof(*sub_res), 8);
589 				if (!sub_res)
590 					panic("%s: Failed to allocate %zu bytes align=0x%x\n",
591 					      __func__, sizeof(*sub_res), 8);
592 				*sub_res = *std_res;
593 				sub_res->end = res->end;
594 				std_res->start = res->end + 1;
595 				request_resource(res, sub_res);
596 			} else {
597 				request_resource(res, std_res);
598 			}
599 		}
600 	}
601 #ifdef CONFIG_CRASH_DUMP
602 	/*
603 	 * Re-add removed crash kernel memory as reserved memory. This makes
604 	 * sure it will be mapped with the identity mapping and struct pages
605 	 * will be created, so it can be resized later on.
606 	 * However add it later since the crash kernel resource should not be
607 	 * part of the System RAM resource.
608 	 */
609 	if (crashk_res.end) {
610 		memblock_add_node(crashk_res.start, resource_size(&crashk_res),
611 				  0, MEMBLOCK_NONE);
612 		memblock_reserve(crashk_res.start, resource_size(&crashk_res));
613 		insert_resource(&iomem_resource, &crashk_res);
614 	}
615 #endif
616 }
617 
618 static void __init setup_memory_end(void)
619 {
620 	memblock_remove(ident_map_size, PHYS_ADDR_MAX - ident_map_size);
621 	max_pfn = max_low_pfn = PFN_DOWN(ident_map_size);
622 	pr_notice("The maximum memory size is %luMB\n", ident_map_size >> 20);
623 }
624 
625 #ifdef CONFIG_CRASH_DUMP
626 
627 /*
628  * When kdump is enabled, we have to ensure that no memory from the area
629  * [0 - crashkernel memory size] is set offline - it will be exchanged with
630  * the crashkernel memory region when kdump is triggered. The crashkernel
631  * memory region can never get offlined (pages are unmovable).
632  */
633 static int kdump_mem_notifier(struct notifier_block *nb,
634 			      unsigned long action, void *data)
635 {
636 	struct memory_notify *arg = data;
637 
638 	if (action != MEM_GOING_OFFLINE)
639 		return NOTIFY_OK;
640 	if (arg->start_pfn < PFN_DOWN(resource_size(&crashk_res)))
641 		return NOTIFY_BAD;
642 	return NOTIFY_OK;
643 }
644 
645 static struct notifier_block kdump_mem_nb = {
646 	.notifier_call = kdump_mem_notifier,
647 };
648 
649 #endif
650 
651 /*
652  * Reserve memory for kdump kernel to be loaded with kexec
653  */
654 static void __init reserve_crashkernel(void)
655 {
656 #ifdef CONFIG_CRASH_DUMP
657 	unsigned long long crash_base, crash_size;
658 	phys_addr_t low, high;
659 	int rc;
660 
661 	rc = parse_crashkernel(boot_command_line, ident_map_size, &crash_size,
662 			       &crash_base);
663 
664 	crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);
665 	crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);
666 	if (rc || crash_size == 0)
667 		return;
668 
669 	if (memblock.memory.regions[0].size < crash_size) {
670 		pr_info("crashkernel reservation failed: %s\n",
671 			"first memory chunk must be at least crashkernel size");
672 		return;
673 	}
674 
675 	low = crash_base ?: oldmem_data.start;
676 	high = low + crash_size;
677 	if (low >= oldmem_data.start && high <= oldmem_data.start + oldmem_data.size) {
678 		/* The crashkernel fits into OLDMEM, reuse OLDMEM */
679 		crash_base = low;
680 	} else {
681 		/* Find suitable area in free memory */
682 		low = max_t(unsigned long, crash_size, sclp.hsa_size);
683 		high = crash_base ? crash_base + crash_size : ULONG_MAX;
684 
685 		if (crash_base && crash_base < low) {
686 			pr_info("crashkernel reservation failed: %s\n",
687 				"crash_base too low");
688 			return;
689 		}
690 		low = crash_base ?: low;
691 		crash_base = memblock_phys_alloc_range(crash_size,
692 						       KEXEC_CRASH_MEM_ALIGN,
693 						       low, high);
694 	}
695 
696 	if (!crash_base) {
697 		pr_info("crashkernel reservation failed: %s\n",
698 			"no suitable area found");
699 		return;
700 	}
701 
702 	if (register_memory_notifier(&kdump_mem_nb)) {
703 		memblock_phys_free(crash_base, crash_size);
704 		return;
705 	}
706 
707 	if (!oldmem_data.start && MACHINE_IS_VM)
708 		diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));
709 	crashk_res.start = crash_base;
710 	crashk_res.end = crash_base + crash_size - 1;
711 	memblock_remove(crash_base, crash_size);
712 	pr_info("Reserving %lluMB of memory at %lluMB "
713 		"for crashkernel (System RAM: %luMB)\n",
714 		crash_size >> 20, crash_base >> 20,
715 		(unsigned long)memblock.memory.total_size >> 20);
716 	os_info_crashkernel_add(crash_base, crash_size);
717 #endif
718 }
719 
720 /*
721  * Reserve the initrd from being used by memblock
722  */
723 static void __init reserve_initrd(void)
724 {
725 #ifdef CONFIG_BLK_DEV_INITRD
726 	if (!initrd_data.start || !initrd_data.size)
727 		return;
728 	initrd_start = (unsigned long)__va(initrd_data.start);
729 	initrd_end = initrd_start + initrd_data.size;
730 	memblock_reserve(initrd_data.start, initrd_data.size);
731 #endif
732 }
733 
734 /*
735  * Reserve the memory area used to pass the certificate lists
736  */
737 static void __init reserve_certificate_list(void)
738 {
739 	if (ipl_cert_list_addr)
740 		memblock_reserve(ipl_cert_list_addr, ipl_cert_list_size);
741 }
742 
743 static void __init reserve_mem_detect_info(void)
744 {
745 	unsigned long start, size;
746 
747 	get_mem_detect_reserved(&start, &size);
748 	if (size)
749 		memblock_reserve(start, size);
750 }
751 
752 static void __init free_mem_detect_info(void)
753 {
754 	unsigned long start, size;
755 
756 	get_mem_detect_reserved(&start, &size);
757 	if (size)
758 		memblock_phys_free(start, size);
759 }
760 
761 static const char * __init get_mem_info_source(void)
762 {
763 	switch (mem_detect.info_source) {
764 	case MEM_DETECT_SCLP_STOR_INFO:
765 		return "sclp storage info";
766 	case MEM_DETECT_DIAG260:
767 		return "diag260";
768 	case MEM_DETECT_SCLP_READ_INFO:
769 		return "sclp read info";
770 	case MEM_DETECT_BIN_SEARCH:
771 		return "binary search";
772 	}
773 	return "none";
774 }
775 
776 static void __init memblock_add_mem_detect_info(void)
777 {
778 	unsigned long start, end;
779 	int i;
780 
781 	pr_debug("physmem info source: %s (%hhd)\n",
782 		 get_mem_info_source(), mem_detect.info_source);
783 	/* keep memblock lists close to the kernel */
784 	memblock_set_bottom_up(true);
785 	for_each_mem_detect_block(i, &start, &end) {
786 		memblock_add(start, end - start);
787 		memblock_physmem_add(start, end - start);
788 	}
789 	memblock_set_bottom_up(false);
790 	memblock_set_node(0, ULONG_MAX, &memblock.memory, 0);
791 }
792 
793 /*
794  * Check for initrd being in usable memory
795  */
796 static void __init check_initrd(void)
797 {
798 #ifdef CONFIG_BLK_DEV_INITRD
799 	if (initrd_data.start && initrd_data.size &&
800 	    !memblock_is_region_memory(initrd_data.start, initrd_data.size)) {
801 		pr_err("The initial RAM disk does not fit into the memory\n");
802 		memblock_phys_free(initrd_data.start, initrd_data.size);
803 		initrd_start = initrd_end = 0;
804 	}
805 #endif
806 }
807 
808 /*
809  * Reserve memory used for lowcore/command line/kernel image.
810  */
811 static void __init reserve_kernel(void)
812 {
813 	memblock_reserve(0, STARTUP_NORMAL_OFFSET);
814 	memblock_reserve(OLDMEM_BASE, sizeof(unsigned long));
815 	memblock_reserve(OLDMEM_SIZE, sizeof(unsigned long));
816 	memblock_reserve(__amode31_base, __eamode31 - __samode31);
817 	memblock_reserve(__pa(sclp_early_sccb), EXT_SCCB_READ_SCP);
818 	memblock_reserve(__pa(_stext), _end - _stext);
819 }
820 
821 static void __init setup_memory(void)
822 {
823 	phys_addr_t start, end;
824 	u64 i;
825 
826 	/*
827 	 * Init storage key for present memory
828 	 */
829 	for_each_mem_range(i, &start, &end)
830 		storage_key_init_range(start, end);
831 
832 	psw_set_key(PAGE_DEFAULT_KEY);
833 }
834 
835 static void __init relocate_amode31_section(void)
836 {
837 	unsigned long amode31_size = __eamode31 - __samode31;
838 	long amode31_offset = __amode31_base - __samode31;
839 	long *ptr;
840 
841 	pr_info("Relocating AMODE31 section of size 0x%08lx\n", amode31_size);
842 
843 	/* Move original AMODE31 section to the new one */
844 	memmove((void *)__amode31_base, (void *)__samode31, amode31_size);
845 	/* Zero out the old AMODE31 section to catch invalid accesses within it */
846 	memset((void *)__samode31, 0, amode31_size);
847 
848 	/* Update all AMODE31 region references */
849 	for (ptr = _start_amode31_refs; ptr != _end_amode31_refs; ptr++)
850 		*ptr += amode31_offset;
851 }
852 
853 /* This must be called after AMODE31 relocation */
854 static void __init setup_cr(void)
855 {
856 	union ctlreg2 cr2;
857 	union ctlreg5 cr5;
858 	union ctlreg15 cr15;
859 
860 	__ctl_duct[1] = (unsigned long)__ctl_aste;
861 	__ctl_duct[2] = (unsigned long)__ctl_aste;
862 	__ctl_duct[4] = (unsigned long)__ctl_duald;
863 
864 	/* Update control registers CR2, CR5 and CR15 */
865 	__ctl_store(cr2.val, 2, 2);
866 	__ctl_store(cr5.val, 5, 5);
867 	__ctl_store(cr15.val, 15, 15);
868 	cr2.ducto = (unsigned long)__ctl_duct >> 6;
869 	cr5.pasteo = (unsigned long)__ctl_duct >> 6;
870 	cr15.lsea = (unsigned long)__ctl_linkage_stack >> 3;
871 	__ctl_load(cr2.val, 2, 2);
872 	__ctl_load(cr5.val, 5, 5);
873 	__ctl_load(cr15.val, 15, 15);
874 }
875 
876 /*
877  * Add system information as device randomness
878  */
879 static void __init setup_randomness(void)
880 {
881 	struct sysinfo_3_2_2 *vmms;
882 
883 	vmms = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
884 	if (!vmms)
885 		panic("Failed to allocate memory for sysinfo structure\n");
886 	if (stsi(vmms, 3, 2, 2) == 0 && vmms->count)
887 		add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count);
888 	memblock_free(vmms, PAGE_SIZE);
889 
890 	if (cpacf_query_func(CPACF_PRNO, CPACF_PRNO_TRNG))
891 		static_branch_enable(&s390_arch_random_available);
892 }
893 
894 /*
895  * Find the correct size for the task_struct. This depends on
896  * the size of the struct fpu at the end of the thread_struct
897  * which is embedded in the task_struct.
898  */
899 static void __init setup_task_size(void)
900 {
901 	int task_size = sizeof(struct task_struct);
902 
903 	if (!MACHINE_HAS_VX) {
904 		task_size -= sizeof(__vector128) * __NUM_VXRS;
905 		task_size += sizeof(freg_t) * __NUM_FPRS;
906 	}
907 	arch_task_struct_size = task_size;
908 }
909 
910 /*
911  * Issue diagnose 318 to set the control program name and
912  * version codes.
913  */
914 static void __init setup_control_program_code(void)
915 {
916 	union diag318_info diag318_info = {
917 		.cpnc = CPNC_LINUX,
918 		.cpvc = 0,
919 	};
920 
921 	if (!sclp.has_diag318)
922 		return;
923 
924 	diag_stat_inc(DIAG_STAT_X318);
925 	asm volatile("diag %0,0,0x318\n" : : "d" (diag318_info.val));
926 }
927 
928 /*
929  * Print the component list from the IPL report
930  */
931 static void __init log_component_list(void)
932 {
933 	struct ipl_rb_component_entry *ptr, *end;
934 	char *str;
935 
936 	if (!early_ipl_comp_list_addr)
937 		return;
938 	if (ipl_block.hdr.flags & IPL_PL_FLAG_SIPL)
939 		pr_info("Linux is running with Secure-IPL enabled\n");
940 	else
941 		pr_info("Linux is running with Secure-IPL disabled\n");
942 	ptr = (void *) early_ipl_comp_list_addr;
943 	end = (void *) ptr + early_ipl_comp_list_size;
944 	pr_info("The IPL report contains the following components:\n");
945 	while (ptr < end) {
946 		if (ptr->flags & IPL_RB_COMPONENT_FLAG_SIGNED) {
947 			if (ptr->flags & IPL_RB_COMPONENT_FLAG_VERIFIED)
948 				str = "signed, verified";
949 			else
950 				str = "signed, verification failed";
951 		} else {
952 			str = "not signed";
953 		}
954 		pr_info("%016llx - %016llx (%s)\n",
955 			ptr->addr, ptr->addr + ptr->len, str);
956 		ptr++;
957 	}
958 }
959 
960 /*
961  * Setup function called from init/main.c just after the banner
962  * was printed.
963  */
964 
965 void __init setup_arch(char **cmdline_p)
966 {
967         /*
968          * print what head.S has found out about the machine
969          */
970 	if (MACHINE_IS_VM)
971 		pr_info("Linux is running as a z/VM "
972 			"guest operating system in 64-bit mode\n");
973 	else if (MACHINE_IS_KVM)
974 		pr_info("Linux is running under KVM in 64-bit mode\n");
975 	else if (MACHINE_IS_LPAR)
976 		pr_info("Linux is running natively in 64-bit mode\n");
977 	else
978 		pr_info("Linux is running as a guest in 64-bit mode\n");
979 
980 	log_component_list();
981 
982 	/* Have one command line that is parsed and saved in /proc/cmdline */
983 	/* boot_command_line has been already set up in early.c */
984 	*cmdline_p = boot_command_line;
985 
986         ROOT_DEV = Root_RAM0;
987 
988 	setup_initial_init_mm(_text, _etext, _edata, _end);
989 
990 	if (IS_ENABLED(CONFIG_EXPOLINE_AUTO))
991 		nospec_auto_detect();
992 
993 	jump_label_init();
994 	parse_early_param();
995 #ifdef CONFIG_CRASH_DUMP
996 	/* Deactivate elfcorehdr= kernel parameter */
997 	elfcorehdr_addr = ELFCORE_ADDR_MAX;
998 #endif
999 
1000 	os_info_init();
1001 	setup_ipl();
1002 	setup_task_size();
1003 	setup_control_program_code();
1004 
1005 	/* Do some memory reservations *before* memory is added to memblock */
1006 	reserve_kernel();
1007 	reserve_initrd();
1008 	reserve_certificate_list();
1009 	reserve_mem_detect_info();
1010 	memblock_set_current_limit(ident_map_size);
1011 	memblock_allow_resize();
1012 
1013 	/* Get information about *all* installed memory */
1014 	memblock_add_mem_detect_info();
1015 
1016 	free_mem_detect_info();
1017 	setup_memory_end();
1018 	memblock_dump_all();
1019 	setup_memory();
1020 
1021 	relocate_amode31_section();
1022 	setup_cr();
1023 	setup_uv();
1024 	dma_contiguous_reserve(ident_map_size);
1025 	vmcp_cma_reserve();
1026 	if (MACHINE_HAS_EDAT2)
1027 		hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
1028 
1029 	check_initrd();
1030 	reserve_crashkernel();
1031 #ifdef CONFIG_CRASH_DUMP
1032 	/*
1033 	 * Be aware that smp_save_dump_secondary_cpus() triggers a system reset.
1034 	 * Therefore CPU and device initialization should be done afterwards.
1035 	 */
1036 	smp_save_dump_secondary_cpus();
1037 #endif
1038 
1039 	setup_resources();
1040 	setup_lowcore_dat_off();
1041 	smp_fill_possible_mask();
1042 	cpu_detect_mhz_feature();
1043         cpu_init();
1044 	numa_setup();
1045 	smp_detect_cpus();
1046 	topology_init_early();
1047 
1048 	if (test_facility(193))
1049 		static_branch_enable(&cpu_has_bear);
1050 
1051 	/*
1052 	 * Create kernel page tables and switch to virtual addressing.
1053 	 */
1054         paging_init();
1055 	memcpy_real_init();
1056 	/*
1057 	 * After paging_init created the kernel page table, the new PSWs
1058 	 * in lowcore can now run with DAT enabled.
1059 	 */
1060 	setup_lowcore_dat_on();
1061 #ifdef CONFIG_CRASH_DUMP
1062 	smp_save_dump_ipl_cpu();
1063 #endif
1064 
1065         /* Setup default console */
1066 	conmode_default();
1067 	set_preferred_console();
1068 
1069 	apply_alternative_instructions();
1070 	if (IS_ENABLED(CONFIG_EXPOLINE))
1071 		nospec_init_branches();
1072 
1073 	/* Setup zfcp/nvme dump support */
1074 	setup_zfcpdump();
1075 
1076 	/* Add system specific data to the random pool */
1077 	setup_randomness();
1078 }
1079