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