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