arch/arm64/kernel/idreg-override.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Early cpufeature override framework
   4  *
   5  * Copyright (C) 2020 Google LLC
   6  * Author: Marc Zyngier <maz@kernel.org>
   7  */
   8
   9 #include <linux/ctype.h>
  10 #include <linux/kernel.h>
  11 #include <linux/libfdt.h>
  12
  13 #include <asm/cacheflush.h>
  14 #include <asm/cpufeature.h>
  15 #include <asm/setup.h>
  16
  17 #define FTR_DESC_NAME_LEN       20
  18 #define FTR_DESC_FIELD_LEN      10
  19 #define FTR_ALIAS_NAME_LEN      30
  20 #define FTR_ALIAS_OPTION_LEN    116
  21
  22 static u64 __boot_status __initdata;
  23
  24 struct ftr_set_desc {
  25         char                            name[FTR_DESC_NAME_LEN];
  26         struct arm64_ftr_override       *override;
  27         struct {
  28                 char                    name[FTR_DESC_FIELD_LEN];
  29                 u8                      shift;
  30                 u8                      width;
  31                 bool                    (*filter)(u64 val);
  32         }                               fields[];
  33 };
  34
  35 #define FIELD(n, s, f)  { .name = n, .shift = s, .width = 4, .filter = f }
  36
  37 static bool __init mmfr1_vh_filter(u64 val)
  38 {
  39         /*
  40          * If we ever reach this point while running VHE, we're
  41          * guaranteed to be on one of these funky, VHE-stuck CPUs. If
  42          * the user was trying to force nVHE on us, proceed with
  43          * attitude adjustment.
  44          */
  45         return !(__boot_status == (BOOT_CPU_FLAG_E2H | BOOT_CPU_MODE_EL2) &&
  46                  val == 0);
  47 }
  48
  49 static const struct ftr_set_desc mmfr1 __initconst = {
  50         .name           = "id_aa64mmfr1",
  51         .override       = &id_aa64mmfr1_override,
  52         .fields         = {
  53                 FIELD("vh", ID_AA64MMFR1_VHE_SHIFT, mmfr1_vh_filter),
  54                 {}
  55         },
  56 };
  57
  58 static bool __init pfr0_sve_filter(u64 val)
  59 {
  60         /*
  61          * Disabling SVE also means disabling all the features that
  62          * are associated with it. The easiest way to do it is just to
  63          * override id_aa64zfr0_el1 to be 0.
  64          */
  65         if (!val) {
  66                 id_aa64zfr0_override.val = 0;
  67                 id_aa64zfr0_override.mask = GENMASK(63, 0);
  68         }
  69
  70         return true;
  71 }
  72
  73 static const struct ftr_set_desc pfr0 __initconst = {
  74         .name           = "id_aa64pfr0",
  75         .override       = &id_aa64pfr0_override,
  76         .fields         = {
  77                 FIELD("sve", ID_AA64PFR0_SVE_SHIFT, pfr0_sve_filter),
  78                 {}
  79         },
  80 };
  81
  82 static bool __init pfr1_sme_filter(u64 val)
  83 {
  84         /*
  85          * Similarly to SVE, disabling SME also means disabling all
  86          * the features that are associated with it. Just set
  87          * id_aa64smfr0_el1 to 0 and don't look back.
  88          */
  89         if (!val) {
  90                 id_aa64smfr0_override.val = 0;
  91                 id_aa64smfr0_override.mask = GENMASK(63, 0);
  92         }
  93
  94         return true;
  95 }
  96
  97 static const struct ftr_set_desc pfr1 __initconst = {
  98         .name           = "id_aa64pfr1",
  99         .override       = &id_aa64pfr1_override,
 100         .fields         = {
 101                 FIELD("bt", ID_AA64PFR1_BT_SHIFT, NULL ),
 102                 FIELD("mte", ID_AA64PFR1_MTE_SHIFT, NULL),
 103                 FIELD("sme", ID_AA64PFR1_SME_SHIFT, pfr1_sme_filter),
 104                 {}
 105         },
 106 };
 107
 108 static const struct ftr_set_desc isar1 __initconst = {
 109         .name           = "id_aa64isar1",
 110         .override       = &id_aa64isar1_override,
 111         .fields         = {
 112                 FIELD("gpi", ID_AA64ISAR1_EL1_GPI_SHIFT, NULL),
 113                 FIELD("gpa", ID_AA64ISAR1_EL1_GPA_SHIFT, NULL),
 114                 FIELD("api", ID_AA64ISAR1_EL1_API_SHIFT, NULL),
 115                 FIELD("apa", ID_AA64ISAR1_EL1_APA_SHIFT, NULL),
 116                 {}
 117         },
 118 };
 119
 120 static const struct ftr_set_desc isar2 __initconst = {
 121         .name           = "id_aa64isar2",
 122         .override       = &id_aa64isar2_override,
 123         .fields         = {
 124                 FIELD("gpa3", ID_AA64ISAR2_EL1_GPA3_SHIFT, NULL),
 125                 FIELD("apa3", ID_AA64ISAR2_EL1_APA3_SHIFT, NULL),
 126                 {}
 127         },
 128 };
 129
 130 static const struct ftr_set_desc smfr0 __initconst = {
 131         .name           = "id_aa64smfr0",
 132         .override       = &id_aa64smfr0_override,
 133         .fields         = {
 134                 /* FA64 is a one bit field... :-/ */
 135                 { "fa64", ID_AA64SMFR0_EL1_FA64_SHIFT, 1, },
 136                 {}
 137         },
 138 };
 139
 140 extern struct arm64_ftr_override kaslr_feature_override;
 141
 142 static const struct ftr_set_desc kaslr __initconst = {
 143         .name           = "kaslr",
 144 #ifdef CONFIG_RANDOMIZE_BASE
 145         .override       = &kaslr_feature_override,
 146 #endif
 147         .fields         = {
 148                 FIELD("disabled", 0, NULL),
 149                 {}
 150         },
 151 };
 152
 153 static const struct ftr_set_desc * const regs[] __initconst = {
 154         &mmfr1,
 155         &pfr0,
 156         &pfr1,
 157         &isar1,
 158         &isar2,
 159         &smfr0,
 160         &kaslr,
 161 };
 162
 163 static const struct {
 164         char    alias[FTR_ALIAS_NAME_LEN];
 165         char    feature[FTR_ALIAS_OPTION_LEN];
 166 } aliases[] __initconst = {
 167         { "kvm-arm.mode=nvhe",          "id_aa64mmfr1.vh=0" },
 168         { "kvm-arm.mode=protected",     "id_aa64mmfr1.vh=0" },
 169         { "arm64.nosve",                "id_aa64pfr0.sve=0 id_aa64pfr1.sme=0" },
 170         { "arm64.nosme",                "id_aa64pfr1.sme=0" },
 171         { "arm64.nobti",                "id_aa64pfr1.bt=0" },
 172         { "arm64.nopauth",
 173           "id_aa64isar1.gpi=0 id_aa64isar1.gpa=0 "
 174           "id_aa64isar1.api=0 id_aa64isar1.apa=0 "
 175           "id_aa64isar2.gpa3=0 id_aa64isar2.apa3=0"        },
 176         { "arm64.nomte",                "id_aa64pfr1.mte=0" },
 177         { "nokaslr",                    "kaslr.disabled=1" },
 178 };
 179
 180 static int __init find_field(const char *cmdline,
 181                              const struct ftr_set_desc *reg, int f, u64 *v)
 182 {
 183         char opt[FTR_DESC_NAME_LEN + FTR_DESC_FIELD_LEN + 2];
 184         int len;
 185
 186         len = snprintf(opt, ARRAY_SIZE(opt), "%s.%s=",
 187                        reg->name, reg->fields[f].name);
 188
 189         if (!parameqn(cmdline, opt, len))
 190                 return -1;
 191
 192         return kstrtou64(cmdline + len, 0, v);
 193 }
 194
 195 static void __init match_options(const char *cmdline)
 196 {
 197         int i;
 198
 199         for (i = 0; i < ARRAY_SIZE(regs); i++) {
 200                 int f;
 201
 202                 if (!regs[i]->override)
 203                         continue;
 204
 205                 for (f = 0; strlen(regs[i]->fields[f].name); f++) {
 206                         u64 shift = regs[i]->fields[f].shift;
 207                         u64 width = regs[i]->fields[f].width ?: 4;
 208                         u64 mask = GENMASK_ULL(shift + width - 1, shift);
 209                         u64 v;
 210
 211                         if (find_field(cmdline, regs[i], f, &v))
 212                                 continue;
 213
 214                         /*
 215                          * If an override gets filtered out, advertise
 216                          * it by setting the value to the all-ones while
 217                          * clearing the mask... Yes, this is fragile.
 218                          */
 219                         if (regs[i]->fields[f].filter &&
 220                             !regs[i]->fields[f].filter(v)) {
 221                                 regs[i]->override->val  |= mask;
 222                                 regs[i]->override->mask &= ~mask;
 223                                 continue;
 224                         }
 225
 226                         regs[i]->override->val  &= ~mask;
 227                         regs[i]->override->val  |= (v << shift) & mask;
 228                         regs[i]->override->mask |= mask;
 229
 230                         return;
 231                 }
 232         }
 233 }
 234
 235 static __init void __parse_cmdline(const char *cmdline, bool parse_aliases)
 236 {
 237         do {
 238                 char buf[256];
 239                 size_t len;
 240                 int i;
 241
 242                 cmdline = skip_spaces(cmdline);
 243
 244                 for (len = 0; cmdline[len] && !isspace(cmdline[len]); len++);
 245                 if (!len)
 246                         return;
 247
 248                 len = min(len, ARRAY_SIZE(buf) - 1);
 249                 strncpy(buf, cmdline, len);
 250                 buf[len] = 0;
 251
 252                 if (strcmp(buf, "--") == 0)
 253                         return;
 254
 255                 cmdline += len;
 256
 257                 match_options(buf);
 258
 259                 for (i = 0; parse_aliases && i < ARRAY_SIZE(aliases); i++)
 260                         if (parameq(buf, aliases[i].alias))
 261                                 __parse_cmdline(aliases[i].feature, false);
 262         } while (1);
 263 }
 264
 265 static __init const u8 *get_bootargs_cmdline(void)
 266 {
 267         const u8 *prop;
 268         void *fdt;
 269         int node;
 270
 271         fdt = get_early_fdt_ptr();
 272         if (!fdt)
 273                 return NULL;
 274
 275         node = fdt_path_offset(fdt, "/chosen");
 276         if (node < 0)
 277                 return NULL;
 278
 279         prop = fdt_getprop(fdt, node, "bootargs", NULL);
 280         if (!prop)
 281                 return NULL;
 282
 283         return strlen(prop) ? prop : NULL;
 284 }
 285
 286 static __init void parse_cmdline(void)
 287 {
 288         const u8 *prop = get_bootargs_cmdline();
 289
 290         if (IS_ENABLED(CONFIG_CMDLINE_FORCE) || !prop)
 291                 __parse_cmdline(CONFIG_CMDLINE, true);
 292
 293         if (!IS_ENABLED(CONFIG_CMDLINE_FORCE) && prop)
 294                 __parse_cmdline(prop, true);
 295 }
 296
 297 /* Keep checkers quiet */
 298 void init_feature_override(u64 boot_status);
 299
 300 asmlinkage void __init init_feature_override(u64 boot_status)
 301 {
 302         int i;
 303
 304         for (i = 0; i < ARRAY_SIZE(regs); i++) {
 305                 if (regs[i]->override) {
 306                         regs[i]->override->val  = 0;
 307                         regs[i]->override->mask = 0;
 308                 }
 309         }
 310
 311         __boot_status = boot_status;
 312
 313         parse_cmdline();
 314
 315         for (i = 0; i < ARRAY_SIZE(regs); i++) {
 316                 if (regs[i]->override)
 317                         dcache_clean_inval_poc((unsigned long)regs[i]->override,
 318                                             (unsigned long)regs[i]->override +
 319                                             sizeof(*regs[i]->override));
 320         }
 321 }