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