arch/s390/kernel/early.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 2007, 2009
   4  *    Author(s): Hongjie Yang <[email protected]>,
   5  */
   6
   7 #define KMSG_COMPONENT "setup"
   8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
   9
  10 #include <linux/compiler.h>
  11 #include <linux/init.h>
  12 #include <linux/errno.h>
  13 #include <linux/string.h>
  14 #include <linux/ctype.h>
  15 #include <linux/lockdep.h>
  16 #include <linux/extable.h>
  17 #include <linux/pfn.h>
  18 #include <linux/uaccess.h>
  19 #include <linux/kernel.h>
  20 #include <asm/asm-extable.h>
  21 #include <linux/memblock.h>
  22 #include <asm/access-regs.h>
  23 #include <asm/diag.h>
  24 #include <asm/ebcdic.h>
  25 #include <asm/fpu.h>
  26 #include <asm/ipl.h>
  27 #include <asm/lowcore.h>
  28 #include <asm/processor.h>
  29 #include <asm/sections.h>
  30 #include <asm/setup.h>
  31 #include <asm/sysinfo.h>
  32 #include <asm/cpcmd.h>
  33 #include <asm/sclp.h>
  34 #include <asm/facility.h>
  35 #include <asm/boot_data.h>
  36 #include "entry.h"
  37
  38 #define decompressor_handled_param(param)                       \
  39 static int __init ignore_decompressor_param_##param(char *s)    \
  40 {                                                               \
  41         return 0;                                               \
  42 }                                                               \
  43 early_param(#param, ignore_decompressor_param_##param)
  44
  45 decompressor_handled_param(mem);
  46 decompressor_handled_param(vmalloc);
  47 decompressor_handled_param(dfltcc);
  48 decompressor_handled_param(facilities);
  49 decompressor_handled_param(nokaslr);
  50 decompressor_handled_param(cmma);
  51 #if IS_ENABLED(CONFIG_KVM)
  52 decompressor_handled_param(prot_virt);
  53 #endif
  54
  55 static void __init kasan_early_init(void)
  56 {
  57 #ifdef CONFIG_KASAN
  58         init_task.kasan_depth = 0;
  59         sclp_early_printk("KernelAddressSanitizer initialized\n");
  60 #endif
  61 }
  62
  63 static void __init reset_tod_clock(void)
  64 {
  65         union tod_clock clk;
  66
  67         if (store_tod_clock_ext_cc(&clk) == 0)
  68                 return;
  69         /* TOD clock not running. Set the clock to Unix Epoch. */
  70         if (set_tod_clock(TOD_UNIX_EPOCH) || store_tod_clock_ext_cc(&clk))
  71                 disabled_wait();
  72
  73         memset(&tod_clock_base, 0, sizeof(tod_clock_base));
  74         tod_clock_base.tod = TOD_UNIX_EPOCH;
  75         S390_lowcore.last_update_clock = TOD_UNIX_EPOCH;
  76 }
  77
  78 /*
  79  * Initialize storage key for kernel pages
  80  */
  81 static noinline __init void init_kernel_storage_key(void)
  82 {
  83 #if PAGE_DEFAULT_KEY
  84         unsigned long end_pfn, init_pfn;
  85
  86         end_pfn = PFN_UP(__pa(_end));
  87
  88         for (init_pfn = 0 ; init_pfn < end_pfn; init_pfn++)
  89                 page_set_storage_key(init_pfn << PAGE_SHIFT,
  90                                      PAGE_DEFAULT_KEY, 0);
  91 #endif
  92 }
  93
  94 static __initdata char sysinfo_page[PAGE_SIZE] __aligned(PAGE_SIZE);
  95
  96 static noinline __init void detect_machine_type(void)
  97 {
  98         struct sysinfo_3_2_2 *vmms = (struct sysinfo_3_2_2 *)&sysinfo_page;
  99
 100         /* Check current-configuration-level */
 101         if (stsi(NULL, 0, 0, 0) <= 2) {
 102                 S390_lowcore.machine_flags |= MACHINE_FLAG_LPAR;
 103                 return;
 104         }
 105         /* Get virtual-machine cpu information. */
 106         if (stsi(vmms, 3, 2, 2) || !vmms->count)
 107                 return;
 108
 109         /* Detect known hypervisors */
 110         if (!memcmp(vmms->vm[0].cpi, "\xd2\xe5\xd4", 3))
 111                 S390_lowcore.machine_flags |= MACHINE_FLAG_KVM;
 112         else if (!memcmp(vmms->vm[0].cpi, "\xa9\x61\xe5\xd4", 4))
 113                 S390_lowcore.machine_flags |= MACHINE_FLAG_VM;
 114 }
 115
 116 /* Remove leading, trailing and double whitespace. */
 117 static inline void strim_all(char *str)
 118 {
 119         char *s;
 120
 121         s = strim(str);
 122         if (s != str)
 123                 memmove(str, s, strlen(s));
 124         while (*str) {
 125                 if (!isspace(*str++))
 126                         continue;
 127                 if (isspace(*str)) {
 128                         s = skip_spaces(str);
 129                         memmove(str, s, strlen(s) + 1);
 130                 }
 131         }
 132 }
 133
 134 static noinline __init void setup_arch_string(void)
 135 {
 136         struct sysinfo_1_1_1 *mach = (struct sysinfo_1_1_1 *)&sysinfo_page;
 137         struct sysinfo_3_2_2 *vm = (struct sysinfo_3_2_2 *)&sysinfo_page;
 138         char mstr[80], hvstr[17];
 139
 140         if (stsi(mach, 1, 1, 1))
 141                 return;
 142         EBCASC(mach->manufacturer, sizeof(mach->manufacturer));
 143         EBCASC(mach->type, sizeof(mach->type));
 144         EBCASC(mach->model, sizeof(mach->model));
 145         EBCASC(mach->model_capacity, sizeof(mach->model_capacity));
 146         sprintf(mstr, "%-16.16s %-4.4s %-16.16s %-16.16s",
 147                 mach->manufacturer, mach->type,
 148                 mach->model, mach->model_capacity);
 149         strim_all(mstr);
 150         if (stsi(vm, 3, 2, 2) == 0 && vm->count) {
 151                 EBCASC(vm->vm[0].cpi, sizeof(vm->vm[0].cpi));
 152                 sprintf(hvstr, "%-16.16s", vm->vm[0].cpi);
 153                 strim_all(hvstr);
 154         } else {
 155                 sprintf(hvstr, "%s",
 156                         MACHINE_IS_LPAR ? "LPAR" :
 157                         MACHINE_IS_VM ? "z/VM" :
 158                         MACHINE_IS_KVM ? "KVM" : "unknown");
 159         }
 160         dump_stack_set_arch_desc("%s (%s)", mstr, hvstr);
 161 }
 162
 163 static __init void setup_topology(void)
 164 {
 165         int max_mnest;
 166
 167         if (!test_facility(11))
 168                 return;
 169         S390_lowcore.machine_flags |= MACHINE_FLAG_TOPOLOGY;
 170         for (max_mnest = 6; max_mnest > 1; max_mnest--) {
 171                 if (stsi(&sysinfo_page, 15, 1, max_mnest) == 0)
 172                         break;
 173         }
 174         topology_max_mnest = max_mnest;
 175 }
 176
 177 void __do_early_pgm_check(struct pt_regs *regs)
 178 {
 179         if (!fixup_exception(regs))
 180                 disabled_wait();
 181 }
 182
 183 static noinline __init void setup_lowcore_early(void)
 184 {
 185         psw_t psw;
 186
 187         psw.addr = (unsigned long)early_pgm_check_handler;
 188         psw.mask = PSW_KERNEL_BITS;
 189         S390_lowcore.program_new_psw = psw;
 190         S390_lowcore.preempt_count = INIT_PREEMPT_COUNT;
 191 }
 192
 193 static noinline __init void setup_facility_list(void)
 194 {
 195         memcpy(alt_stfle_fac_list, stfle_fac_list, sizeof(alt_stfle_fac_list));
 196         if (!IS_ENABLED(CONFIG_KERNEL_NOBP))
 197                 __clear_facility(82, alt_stfle_fac_list);
 198 }
 199
 200 static __init void detect_diag9c(void)
 201 {
 202         unsigned int cpu_address;
 203         int rc;
 204
 205         cpu_address = stap();
 206         diag_stat_inc(DIAG_STAT_X09C);
 207         asm volatile(
 208                 "       diag    %2,0,0x9c\n"
 209                 "0:     la      %0,0\n"
 210                 "1:\n"
 211                 EX_TABLE(0b,1b)
 212                 : "=d" (rc) : "0" (-EOPNOTSUPP), "d" (cpu_address) : "cc");
 213         if (!rc)
 214                 S390_lowcore.machine_flags |= MACHINE_FLAG_DIAG9C;
 215 }
 216
 217 static __init void detect_machine_facilities(void)
 218 {
 219         if (test_facility(8)) {
 220                 S390_lowcore.machine_flags |= MACHINE_FLAG_EDAT1;
 221                 system_ctl_set_bit(0, CR0_EDAT_BIT);
 222         }
 223         if (test_facility(78))
 224                 S390_lowcore.machine_flags |= MACHINE_FLAG_EDAT2;
 225         if (test_facility(3))
 226                 S390_lowcore.machine_flags |= MACHINE_FLAG_IDTE;
 227         if (test_facility(50) && test_facility(73)) {
 228                 S390_lowcore.machine_flags |= MACHINE_FLAG_TE;
 229                 system_ctl_set_bit(0, CR0_TRANSACTIONAL_EXECUTION_BIT);
 230         }
 231         if (test_facility(51))
 232                 S390_lowcore.machine_flags |= MACHINE_FLAG_TLB_LC;
 233         if (test_facility(129))
 234                 system_ctl_set_bit(0, CR0_VECTOR_BIT);
 235         if (test_facility(130))
 236                 S390_lowcore.machine_flags |= MACHINE_FLAG_NX;
 237         if (test_facility(133))
 238                 S390_lowcore.machine_flags |= MACHINE_FLAG_GS;
 239         if (test_facility(139) && (tod_clock_base.tod >> 63)) {
 240                 /* Enabled signed clock comparator comparisons */
 241                 S390_lowcore.machine_flags |= MACHINE_FLAG_SCC;
 242                 clock_comparator_max = -1ULL >> 1;
 243                 system_ctl_set_bit(0, CR0_CLOCK_COMPARATOR_SIGN_BIT);
 244         }
 245         if (IS_ENABLED(CONFIG_PCI) && test_facility(153)) {
 246                 S390_lowcore.machine_flags |= MACHINE_FLAG_PCI_MIO;
 247                 /* the control bit is set during PCI initialization */
 248         }
 249         if (test_facility(194))
 250                 S390_lowcore.machine_flags |= MACHINE_FLAG_RDP;
 251 }
 252
 253 static inline void save_vector_registers(void)
 254 {
 255 #ifdef CONFIG_CRASH_DUMP
 256         if (test_facility(129))
 257                 save_vx_regs(boot_cpu_vector_save_area);
 258 #endif
 259 }
 260
 261 static inline void setup_low_address_protection(void)
 262 {
 263         system_ctl_set_bit(0, CR0_LOW_ADDRESS_PROTECTION_BIT);
 264 }
 265
 266 static inline void setup_access_registers(void)
 267 {
 268         unsigned int acrs[NUM_ACRS] = { 0 };
 269
 270         restore_access_regs(acrs);
 271 }
 272
 273 char __bootdata(early_command_line)[COMMAND_LINE_SIZE];
 274 static void __init setup_boot_command_line(void)
 275 {
 276         /* copy arch command line */
 277         strscpy(boot_command_line, early_command_line, COMMAND_LINE_SIZE);
 278 }
 279
 280 static void __init sort_amode31_extable(void)
 281 {
 282         sort_extable(__start_amode31_ex_table, __stop_amode31_ex_table);
 283 }
 284
 285 void __init startup_init(void)
 286 {
 287         kasan_early_init();
 288         reset_tod_clock();
 289         time_early_init();
 290         init_kernel_storage_key();
 291         lockdep_off();
 292         sort_amode31_extable();
 293         setup_lowcore_early();
 294         setup_facility_list();
 295         detect_machine_type();
 296         setup_arch_string();
 297         setup_boot_command_line();
 298         detect_diag9c();
 299         detect_machine_facilities();
 300         save_vector_registers();
 301         setup_topology();
 302         sclp_early_detect();
 303         setup_low_address_protection();
 304         setup_access_registers();
 305         lockdep_on();
 306 }