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