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