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