1
2
3
4
5
6
7
8
9
10
11
12
13
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
83
84unsigned int console_mode = 0;
85EXPORT_SYMBOL(console_mode);
86
87unsigned int console_devno = -1;
88EXPORT_SYMBOL(console_devno);
89
90unsigned int console_irq = -1;
91EXPORT_SYMBOL(console_irq);
92
93
94
95
96
97
98unsigned long __amode31_ref __samode31 = __pa(&_samode31);
99unsigned long __amode31_ref __eamode31 = __pa(&_eamode31);
100unsigned long __amode31_ref __stext_amode31 = __pa(&_stext_amode31);
101unsigned long __amode31_ref __etext_amode31 = __pa(&_etext_amode31);
102struct exception_table_entry __amode31_ref *__start_amode31_ex_table = _start_amode31_ex_table;
103struct exception_table_entry __amode31_ref *__stop_amode31_ex_table = _stop_amode31_ex_table;
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119static __amode31_data u32 __ctl_duct_amode31[16] __aligned(64);
120
121static __amode31_data u64 __ctl_aste_amode31[8] __aligned(64) = {
122 [1] = 0xffffffffffffffff
123};
124
125static __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
136static __amode31_data u32 __ctl_linkage_stack_amode31[8] __aligned(64) = {
137 0, 0, 0x89000000, 0,
138 0, 0, 0x8a000000, 0
139};
140
141static u64 __amode31_ref *__ctl_aste = __ctl_aste_amode31;
142static u32 __amode31_ref *__ctl_duald = __ctl_duald_amode31;
143static u32 __amode31_ref *__ctl_linkage_stack = __ctl_linkage_stack_amode31;
144static u32 __amode31_ref *__ctl_duct = __ctl_duct_amode31;
145
146int __bootdata(noexec_disabled);
147unsigned long __bootdata(ident_map_size);
148struct mem_detect_info __bootdata(mem_detect);
149struct initrd_data __bootdata(initrd_data);
150
151unsigned long __bootdata_preserved(__kaslr_offset);
152unsigned int __bootdata_preserved(zlib_dfltcc_support);
153EXPORT_SYMBOL(zlib_dfltcc_support);
154u64 __bootdata_preserved(stfle_fac_list[16]);
155EXPORT_SYMBOL(stfle_fac_list);
156u64 __bootdata_preserved(alt_stfle_fac_list[16]);
157struct oldmem_data __bootdata_preserved(oldmem_data);
158
159unsigned long VMALLOC_START;
160EXPORT_SYMBOL(VMALLOC_START);
161
162unsigned long VMALLOC_END;
163EXPORT_SYMBOL(VMALLOC_END);
164
165struct page *vmemmap;
166EXPORT_SYMBOL(vmemmap);
167unsigned long vmemmap_size;
168
169unsigned long MODULES_VADDR;
170unsigned long MODULES_END;
171
172
173struct lowcore *lowcore_ptr[NR_CPUS];
174EXPORT_SYMBOL(lowcore_ptr);
175
176
177
178
179
180unsigned long mio_wb_bit_mask __ro_after_init;
181
182
183
184
185
186
187
188#include <asm/setup.h>
189
190
191
192
193
194static 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
208static 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
220static 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
240static 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
254
255
256
257
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
298static 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
308static inline void setup_zfcpdump(void) {}
309#endif
310
311
312
313
314
315
316void machine_restart(char *command)
317{
318 if ((!in_interrupt() && !in_atomic()) || oops_in_progress)
319
320
321
322
323 console_unblank();
324 _machine_restart(command);
325}
326
327void machine_halt(void)
328{
329 if (!in_interrupt() || oops_in_progress)
330
331
332
333
334 console_unblank();
335 _machine_halt();
336}
337
338void machine_power_off(void)
339{
340 if (!in_interrupt() || oops_in_progress)
341
342
343
344
345 console_unblank();
346 _machine_power_off();
347}
348
349
350
351
352void (*pm_power_off)(void) = machine_power_off;
353EXPORT_SYMBOL_GPL(pm_power_off);
354
355void *restart_stack;
356
357unsigned 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
371void 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
380int __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
391void __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
408static 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
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
456
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
466
467
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
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;
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
499static 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
516static struct resource code_resource = {
517 .name = "Kernel code",
518 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
519};
520
521static struct resource data_resource = {
522 .name = "Kernel data",
523 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
524};
525
526static struct resource bss_resource = {
527 .name = "Kernel bss",
528 .flags = IORESOURCE_BUSY | IORESOURCE_SYSTEM_RAM,
529};
530
531static struct resource __initdata *standard_resources[] = {
532 &code_resource,
533 &data_resource,
534 &bss_resource,
535};
536
537static 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
562
563
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
590
591
592
593
594
595 if (crashk_res.end) {
596 memblock_add_node(crashk_res.start, resource_size(&crashk_res), 0);
597 memblock_reserve(crashk_res.start, resource_size(&crashk_res));
598 insert_resource(&iomem_resource, &crashk_res);
599 }
600#endif
601}
602
603static void __init setup_memory_end(void)
604{
605 memblock_remove(ident_map_size, ULONG_MAX);
606 max_pfn = max_low_pfn = PFN_DOWN(ident_map_size);
607 pr_notice("The maximum memory size is %luMB\n", ident_map_size >> 20);
608}
609
610#ifdef CONFIG_CRASH_DUMP
611
612
613
614
615
616
617
618static int kdump_mem_notifier(struct notifier_block *nb,
619 unsigned long action, void *data)
620{
621 struct memory_notify *arg = data;
622
623 if (action != MEM_GOING_OFFLINE)
624 return NOTIFY_OK;
625 if (arg->start_pfn < PFN_DOWN(resource_size(&crashk_res)))
626 return NOTIFY_BAD;
627 return NOTIFY_OK;
628}
629
630static struct notifier_block kdump_mem_nb = {
631 .notifier_call = kdump_mem_notifier,
632};
633
634#endif
635
636
637
638
639static void __init reserve_above_ident_map(void)
640{
641 memblock_reserve(ident_map_size, ULONG_MAX);
642}
643
644
645
646
647static void __init reserve_crashkernel(void)
648{
649#ifdef CONFIG_CRASH_DUMP
650 unsigned long long crash_base, crash_size;
651 phys_addr_t low, high;
652 int rc;
653
654 rc = parse_crashkernel(boot_command_line, ident_map_size, &crash_size,
655 &crash_base);
656
657 crash_base = ALIGN(crash_base, KEXEC_CRASH_MEM_ALIGN);
658 crash_size = ALIGN(crash_size, KEXEC_CRASH_MEM_ALIGN);
659 if (rc || crash_size == 0)
660 return;
661
662 if (memblock.memory.regions[0].size < crash_size) {
663 pr_info("crashkernel reservation failed: %s\n",
664 "first memory chunk must be at least crashkernel size");
665 return;
666 }
667
668 low = crash_base ?: oldmem_data.start;
669 high = low + crash_size;
670 if (low >= oldmem_data.start && high <= oldmem_data.start + oldmem_data.size) {
671
672 crash_base = low;
673 } else {
674
675 low = max_t(unsigned long, crash_size, sclp.hsa_size);
676 high = crash_base ? crash_base + crash_size : ULONG_MAX;
677
678 if (crash_base && crash_base < low) {
679 pr_info("crashkernel reservation failed: %s\n",
680 "crash_base too low");
681 return;
682 }
683 low = crash_base ?: low;
684 crash_base = memblock_phys_alloc_range(crash_size,
685 KEXEC_CRASH_MEM_ALIGN,
686 low, high);
687 }
688
689 if (!crash_base) {
690 pr_info("crashkernel reservation failed: %s\n",
691 "no suitable area found");
692 return;
693 }
694
695 if (register_memory_notifier(&kdump_mem_nb)) {
696 memblock_free(crash_base, crash_size);
697 return;
698 }
699
700 if (!oldmem_data.start && MACHINE_IS_VM)
701 diag10_range(PFN_DOWN(crash_base), PFN_DOWN(crash_size));
702 crashk_res.start = crash_base;
703 crashk_res.end = crash_base + crash_size - 1;
704 memblock_remove(crash_base, crash_size);
705 pr_info("Reserving %lluMB of memory at %lluMB "
706 "for crashkernel (System RAM: %luMB)\n",
707 crash_size >> 20, crash_base >> 20,
708 (unsigned long)memblock.memory.total_size >> 20);
709 os_info_crashkernel_add(crash_base, crash_size);
710#endif
711}
712
713
714
715
716static void __init reserve_initrd(void)
717{
718#ifdef CONFIG_BLK_DEV_INITRD
719 if (!initrd_data.start || !initrd_data.size)
720 return;
721 initrd_start = initrd_data.start;
722 initrd_end = initrd_start + initrd_data.size;
723 memblock_reserve(initrd_data.start, initrd_data.size);
724#endif
725}
726
727
728
729
730static void __init reserve_certificate_list(void)
731{
732 if (ipl_cert_list_addr)
733 memblock_reserve(ipl_cert_list_addr, ipl_cert_list_size);
734}
735
736static void __init reserve_mem_detect_info(void)
737{
738 unsigned long start, size;
739
740 get_mem_detect_reserved(&start, &size);
741 if (size)
742 memblock_reserve(start, size);
743}
744
745static void __init free_mem_detect_info(void)
746{
747 unsigned long start, size;
748
749 get_mem_detect_reserved(&start, &size);
750 if (size)
751 memblock_free(start, size);
752}
753
754static const char * __init get_mem_info_source(void)
755{
756 switch (mem_detect.info_source) {
757 case MEM_DETECT_SCLP_STOR_INFO:
758 return "sclp storage info";
759 case MEM_DETECT_DIAG260:
760 return "diag260";
761 case MEM_DETECT_SCLP_READ_INFO:
762 return "sclp read info";
763 case MEM_DETECT_BIN_SEARCH:
764 return "binary search";
765 }
766 return "none";
767}
768
769static void __init memblock_add_mem_detect_info(void)
770{
771 unsigned long start, end;
772 int i;
773
774 pr_debug("physmem info source: %s (%hhd)\n",
775 get_mem_info_source(), mem_detect.info_source);
776
777 memblock_set_bottom_up(true);
778 for_each_mem_detect_block(i, &start, &end) {
779 memblock_add(start, end - start);
780 memblock_physmem_add(start, end - start);
781 }
782 memblock_set_bottom_up(false);
783 memblock_set_node(0, ULONG_MAX, &memblock.memory, 0);
784 memblock_dump_all();
785}
786
787
788
789
790static void __init check_initrd(void)
791{
792#ifdef CONFIG_BLK_DEV_INITRD
793 if (initrd_data.start && initrd_data.size &&
794 !memblock_is_region_memory(initrd_data.start, initrd_data.size)) {
795 pr_err("The initial RAM disk does not fit into the memory\n");
796 memblock_free(initrd_data.start, initrd_data.size);
797 initrd_start = initrd_end = 0;
798 }
799#endif
800}
801
802
803
804
805static void __init reserve_kernel(void)
806{
807 unsigned long start_pfn = PFN_UP(__pa(_end));
808
809 memblock_reserve(0, STARTUP_NORMAL_OFFSET);
810 memblock_reserve((unsigned long)sclp_early_sccb, EXT_SCCB_READ_SCP);
811 memblock_reserve((unsigned long)_stext, PFN_PHYS(start_pfn)
812 - (unsigned long)_stext);
813}
814
815static void __init setup_memory(void)
816{
817 phys_addr_t start, end;
818 u64 i;
819
820
821
822
823 for_each_mem_range(i, &start, &end)
824 storage_key_init_range(start, end);
825
826 psw_set_key(PAGE_DEFAULT_KEY);
827
828
829 memblock_enforce_memory_limit(memblock_end_of_DRAM());
830}
831
832static void __init relocate_amode31_section(void)
833{
834 unsigned long amode31_addr, amode31_size;
835 long amode31_offset;
836 long *ptr;
837
838
839 amode31_size = __eamode31 - __samode31;
840 pr_info("Relocating AMODE31 section of size 0x%08lx\n", amode31_size);
841 amode31_addr = (unsigned long)memblock_alloc_low(amode31_size, PAGE_SIZE);
842 if (!amode31_addr)
843 panic("Failed to allocate memory for AMODE31 section\n");
844 amode31_offset = amode31_addr - __samode31;
845
846
847 memmove((void *)amode31_addr, (void *)__samode31, amode31_size);
848
849 memset((void *)__samode31, 0, amode31_size);
850
851
852 for (ptr = _start_amode31_refs; ptr != _end_amode31_refs; ptr++)
853 *ptr += amode31_offset;
854}
855
856
857static void __init setup_cr(void)
858{
859 union ctlreg2 cr2;
860 union ctlreg5 cr5;
861 union ctlreg15 cr15;
862
863 __ctl_duct[1] = (unsigned long)__ctl_aste;
864 __ctl_duct[2] = (unsigned long)__ctl_aste;
865 __ctl_duct[4] = (unsigned long)__ctl_duald;
866
867
868 __ctl_store(cr2.val, 2, 2);
869 __ctl_store(cr5.val, 5, 5);
870 __ctl_store(cr15.val, 15, 15);
871 cr2.ducto = (unsigned long)__ctl_duct >> 6;
872 cr5.pasteo = (unsigned long)__ctl_duct >> 6;
873 cr15.lsea = (unsigned long)__ctl_linkage_stack >> 3;
874 __ctl_load(cr2.val, 2, 2);
875 __ctl_load(cr5.val, 5, 5);
876 __ctl_load(cr15.val, 15, 15);
877}
878
879
880
881
882static void __init setup_randomness(void)
883{
884 struct sysinfo_3_2_2 *vmms;
885
886 vmms = (struct sysinfo_3_2_2 *) memblock_phys_alloc(PAGE_SIZE,
887 PAGE_SIZE);
888 if (!vmms)
889 panic("Failed to allocate memory for sysinfo structure\n");
890
891 if (stsi(vmms, 3, 2, 2) == 0 && vmms->count)
892 add_device_randomness(&vmms->vm, sizeof(vmms->vm[0]) * vmms->count);
893 memblock_free((unsigned long) vmms, PAGE_SIZE);
894}
895
896
897
898
899
900
901static void __init setup_task_size(void)
902{
903 int task_size = sizeof(struct task_struct);
904
905 if (!MACHINE_HAS_VX) {
906 task_size -= sizeof(__vector128) * __NUM_VXRS;
907 task_size += sizeof(freg_t) * __NUM_FPRS;
908 }
909 arch_task_struct_size = task_size;
910}
911
912
913
914
915
916static void __init setup_control_program_code(void)
917{
918 union diag318_info diag318_info = {
919 .cpnc = CPNC_LINUX,
920 .cpvc = 0,
921 };
922
923 if (!sclp.has_diag318)
924 return;
925
926 diag_stat_inc(DIAG_STAT_X318);
927 asm volatile("diag %0,0,0x318\n" : : "d" (diag318_info.val));
928}
929
930
931
932
933static void __init log_component_list(void)
934{
935 struct ipl_rb_component_entry *ptr, *end;
936 char *str;
937
938 if (!early_ipl_comp_list_addr)
939 return;
940 if (ipl_block.hdr.flags & IPL_PL_FLAG_SIPL)
941 pr_info("Linux is running with Secure-IPL enabled\n");
942 else
943 pr_info("Linux is running with Secure-IPL disabled\n");
944 ptr = (void *) early_ipl_comp_list_addr;
945 end = (void *) ptr + early_ipl_comp_list_size;
946 pr_info("The IPL report contains the following components:\n");
947 while (ptr < end) {
948 if (ptr->flags & IPL_RB_COMPONENT_FLAG_SIGNED) {
949 if (ptr->flags & IPL_RB_COMPONENT_FLAG_VERIFIED)
950 str = "signed, verified";
951 else
952 str = "signed, verification failed";
953 } else {
954 str = "not signed";
955 }
956 pr_info("%016llx - %016llx (%s)\n",
957 ptr->addr, ptr->addr + ptr->len, str);
958 ptr++;
959 }
960}
961
962
963
964
965
966
967void __init setup_arch(char **cmdline_p)
968{
969
970
971
972 if (MACHINE_IS_VM)
973 pr_info("Linux is running as a z/VM "
974 "guest operating system in 64-bit mode\n");
975 else if (MACHINE_IS_KVM)
976 pr_info("Linux is running under KVM in 64-bit mode\n");
977 else if (MACHINE_IS_LPAR)
978 pr_info("Linux is running natively in 64-bit mode\n");
979 else
980 pr_info("Linux is running as a guest in 64-bit mode\n");
981
982 log_component_list();
983
984
985
986 *cmdline_p = boot_command_line;
987
988 ROOT_DEV = Root_RAM0;
989
990 setup_initial_init_mm(_text, _etext, _edata, _end);
991
992 if (IS_ENABLED(CONFIG_EXPOLINE_AUTO))
993 nospec_auto_detect();
994
995 jump_label_init();
996 parse_early_param();
997#ifdef CONFIG_CRASH_DUMP
998
999 elfcorehdr_addr = ELFCORE_ADDR_MAX;
1000#endif
1001
1002 os_info_init();
1003 setup_ipl();
1004 setup_task_size();
1005 setup_control_program_code();
1006
1007
1008 reserve_above_ident_map();
1009 reserve_kernel();
1010 reserve_initrd();
1011 reserve_certificate_list();
1012 reserve_mem_detect_info();
1013 memblock_allow_resize();
1014
1015
1016 memblock_add_mem_detect_info();
1017
1018 free_mem_detect_info();
1019
1020 relocate_amode31_section();
1021 setup_cr();
1022
1023 setup_uv();
1024 setup_memory_end();
1025 setup_memory();
1026 dma_contiguous_reserve(ident_map_size);
1027 vmcp_cma_reserve();
1028 if (MACHINE_HAS_EDAT2)
1029 hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
1030
1031 check_initrd();
1032 reserve_crashkernel();
1033#ifdef CONFIG_CRASH_DUMP
1034
1035
1036
1037
1038 smp_save_dump_cpus();
1039#endif
1040
1041 setup_resources();
1042 setup_lowcore_dat_off();
1043 smp_fill_possible_mask();
1044 cpu_detect_mhz_feature();
1045 cpu_init();
1046 numa_setup();
1047 smp_detect_cpus();
1048 topology_init_early();
1049
1050
1051
1052
1053 paging_init();
1054
1055
1056
1057
1058
1059 setup_lowcore_dat_on();
1060
1061
1062 conmode_default();
1063 set_preferred_console();
1064
1065 apply_alternative_instructions();
1066 if (IS_ENABLED(CONFIG_EXPOLINE))
1067 nospec_init_branches();
1068
1069
1070 setup_zfcpdump();
1071
1072
1073 setup_randomness();
1074}
1075