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