arm64/kernel/idreg-override.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Early cpufeature override framework
0004  *
0005  * Copyright (C) 2020 Google LLC
0006  * Author: Marc Zyngier <maz@kernel.org>
0007  */
0008
0009 #include <linux/ctype.h>
0010 #include <linux/kernel.h>
0011 #include <linux/libfdt.h>
0012
0013 #include <asm/cacheflush.h>
0014 #include <asm/cpufeature.h>
0015 #include <asm/setup.h>
0016
0017 #define FTR_DESC_NAME_LEN   20
0018 #define FTR_DESC_FIELD_LEN  10
0019 #define FTR_ALIAS_NAME_LEN  30
0020 #define FTR_ALIAS_OPTION_LEN    116
0021
0022 static u64 __boot_status __initdata;
0023
0024 struct ftr_set_desc {
0025     char                name[FTR_DESC_NAME_LEN];
0026     struct arm64_ftr_override   *override;
0027     struct {
0028         char            name[FTR_DESC_FIELD_LEN];
0029         u8          shift;
0030         u8          width;
0031         bool            (*filter)(u64 val);
0032     }               fields[];
0033 };
0034
0035 #define FIELD(n, s, f)  { .name = n, .shift = s, .width = 4, .filter = f }
0036
0037 static bool __init mmfr1_vh_filter(u64 val)
0038 {
0039     /*
0040      * If we ever reach this point while running VHE, we're
0041      * guaranteed to be on one of these funky, VHE-stuck CPUs. If
0042      * the user was trying to force nVHE on us, proceed with
0043      * attitude adjustment.
0044      */
0045     return !(__boot_status == (BOOT_CPU_FLAG_E2H | BOOT_CPU_MODE_EL2) &&
0046          val == 0);
0047 }
0048
0049 static const struct ftr_set_desc mmfr1 __initconst = {
0050     .name       = "id_aa64mmfr1",
0051     .override   = &id_aa64mmfr1_override,
0052     .fields     = {
0053         FIELD("vh", ID_AA64MMFR1_VHE_SHIFT, mmfr1_vh_filter),
0054         {}
0055     },
0056 };
0057
0058 static bool __init pfr0_sve_filter(u64 val)
0059 {
0060     /*
0061      * Disabling SVE also means disabling all the features that
0062      * are associated with it. The easiest way to do it is just to
0063      * override id_aa64zfr0_el1 to be 0.
0064      */
0065     if (!val) {
0066         id_aa64zfr0_override.val = 0;
0067         id_aa64zfr0_override.mask = GENMASK(63, 0);
0068     }
0069
0070     return true;
0071 }
0072
0073 static const struct ftr_set_desc pfr0 __initconst = {
0074     .name       = "id_aa64pfr0",
0075     .override   = &id_aa64pfr0_override,
0076     .fields     = {
0077             FIELD("sve", ID_AA64PFR0_SVE_SHIFT, pfr0_sve_filter),
0078         {}
0079     },
0080 };
0081
0082 static bool __init pfr1_sme_filter(u64 val)
0083 {
0084     /*
0085      * Similarly to SVE, disabling SME also means disabling all
0086      * the features that are associated with it. Just set
0087      * id_aa64smfr0_el1 to 0 and don't look back.
0088      */
0089     if (!val) {
0090         id_aa64smfr0_override.val = 0;
0091         id_aa64smfr0_override.mask = GENMASK(63, 0);
0092     }
0093
0094     return true;
0095 }
0096
0097 static const struct ftr_set_desc pfr1 __initconst = {
0098     .name       = "id_aa64pfr1",
0099     .override   = &id_aa64pfr1_override,
0100     .fields     = {
0101         FIELD("bt", ID_AA64PFR1_BT_SHIFT, NULL ),
0102         FIELD("mte", ID_AA64PFR1_MTE_SHIFT, NULL),
0103         FIELD("sme", ID_AA64PFR1_SME_SHIFT, pfr1_sme_filter),
0104         {}
0105     },
0106 };
0107
0108 static const struct ftr_set_desc isar1 __initconst = {
0109     .name       = "id_aa64isar1",
0110     .override   = &id_aa64isar1_override,
0111     .fields     = {
0112         FIELD("gpi", ID_AA64ISAR1_EL1_GPI_SHIFT, NULL),
0113         FIELD("gpa", ID_AA64ISAR1_EL1_GPA_SHIFT, NULL),
0114         FIELD("api", ID_AA64ISAR1_EL1_API_SHIFT, NULL),
0115         FIELD("apa", ID_AA64ISAR1_EL1_APA_SHIFT, NULL),
0116         {}
0117     },
0118 };
0119
0120 static const struct ftr_set_desc isar2 __initconst = {
0121     .name       = "id_aa64isar2",
0122     .override   = &id_aa64isar2_override,
0123     .fields     = {
0124         FIELD("gpa3", ID_AA64ISAR2_EL1_GPA3_SHIFT, NULL),
0125         FIELD("apa3", ID_AA64ISAR2_EL1_APA3_SHIFT, NULL),
0126         {}
0127     },
0128 };
0129
0130 static const struct ftr_set_desc smfr0 __initconst = {
0131     .name       = "id_aa64smfr0",
0132     .override   = &id_aa64smfr0_override,
0133     .fields     = {
0134         /* FA64 is a one bit field... :-/ */
0135         { "fa64", ID_AA64SMFR0_EL1_FA64_SHIFT, 1, },
0136         {}
0137     },
0138 };
0139
0140 extern struct arm64_ftr_override kaslr_feature_override;
0141
0142 static const struct ftr_set_desc kaslr __initconst = {
0143     .name       = "kaslr",
0144 #ifdef CONFIG_RANDOMIZE_BASE
0145     .override   = &kaslr_feature_override,
0146 #endif
0147     .fields     = {
0148         FIELD("disabled", 0, NULL),
0149         {}
0150     },
0151 };
0152
0153 static const struct ftr_set_desc * const regs[] __initconst = {
0154     &mmfr1,
0155     &pfr0,
0156     &pfr1,
0157     &isar1,
0158     &isar2,
0159     &smfr0,
0160     &kaslr,
0161 };
0162
0163 static const struct {
0164     char    alias[FTR_ALIAS_NAME_LEN];
0165     char    feature[FTR_ALIAS_OPTION_LEN];
0166 } aliases[] __initconst = {
0167     { "kvm-arm.mode=nvhe",      "id_aa64mmfr1.vh=0" },
0168     { "kvm-arm.mode=protected", "id_aa64mmfr1.vh=0" },
0169     { "arm64.nosve",        "id_aa64pfr0.sve=0 id_aa64pfr1.sme=0" },
0170     { "arm64.nosme",        "id_aa64pfr1.sme=0" },
0171     { "arm64.nobti",        "id_aa64pfr1.bt=0" },
0172     { "arm64.nopauth",
0173       "id_aa64isar1.gpi=0 id_aa64isar1.gpa=0 "
0174       "id_aa64isar1.api=0 id_aa64isar1.apa=0 "
0175       "id_aa64isar2.gpa3=0 id_aa64isar2.apa3=0"    },
0176     { "arm64.nomte",        "id_aa64pfr1.mte=0" },
0177     { "nokaslr",            "kaslr.disabled=1" },
0178 };
0179
0180 static int __init find_field(const char *cmdline,
0181                  const struct ftr_set_desc *reg, int f, u64 *v)
0182 {
0183     char opt[FTR_DESC_NAME_LEN + FTR_DESC_FIELD_LEN + 2];
0184     int len;
0185
0186     len = snprintf(opt, ARRAY_SIZE(opt), "%s.%s=",
0187                reg->name, reg->fields[f].name);
0188
0189     if (!parameqn(cmdline, opt, len))
0190         return -1;
0191
0192     return kstrtou64(cmdline + len, 0, v);
0193 }
0194
0195 static void __init match_options(const char *cmdline)
0196 {
0197     int i;
0198
0199     for (i = 0; i < ARRAY_SIZE(regs); i++) {
0200         int f;
0201
0202         if (!regs[i]->override)
0203             continue;
0204
0205         for (f = 0; strlen(regs[i]->fields[f].name); f++) {
0206             u64 shift = regs[i]->fields[f].shift;
0207             u64 width = regs[i]->fields[f].width ?: 4;
0208             u64 mask = GENMASK_ULL(shift + width - 1, shift);
0209             u64 v;
0210
0211             if (find_field(cmdline, regs[i], f, &v))
0212                 continue;
0213
0214             /*
0215              * If an override gets filtered out, advertise
0216              * it by setting the value to the all-ones while
0217              * clearing the mask... Yes, this is fragile.
0218              */
0219             if (regs[i]->fields[f].filter &&
0220                 !regs[i]->fields[f].filter(v)) {
0221                 regs[i]->override->val  |= mask;
0222                 regs[i]->override->mask &= ~mask;
0223                 continue;
0224             }
0225
0226             regs[i]->override->val  &= ~mask;
0227             regs[i]->override->val  |= (v << shift) & mask;
0228             regs[i]->override->mask |= mask;
0229
0230             return;
0231         }
0232     }
0233 }
0234
0235 static __init void __parse_cmdline(const char *cmdline, bool parse_aliases)
0236 {
0237     do {
0238         char buf[256];
0239         size_t len;
0240         int i;
0241
0242         cmdline = skip_spaces(cmdline);
0243
0244         for (len = 0; cmdline[len] && !isspace(cmdline[len]); len++);
0245         if (!len)
0246             return;
0247
0248         len = min(len, ARRAY_SIZE(buf) - 1);
0249         strncpy(buf, cmdline, len);
0250         buf[len] = 0;
0251
0252         if (strcmp(buf, "--") == 0)
0253             return;
0254
0255         cmdline += len;
0256
0257         match_options(buf);
0258
0259         for (i = 0; parse_aliases && i < ARRAY_SIZE(aliases); i++)
0260             if (parameq(buf, aliases[i].alias))
0261                 __parse_cmdline(aliases[i].feature, false);
0262     } while (1);
0263 }
0264
0265 static __init const u8 *get_bootargs_cmdline(void)
0266 {
0267     const u8 *prop;
0268     void *fdt;
0269     int node;
0270
0271     fdt = get_early_fdt_ptr();
0272     if (!fdt)
0273         return NULL;
0274
0275     node = fdt_path_offset(fdt, "/chosen");
0276     if (node < 0)
0277         return NULL;
0278
0279     prop = fdt_getprop(fdt, node, "bootargs", NULL);
0280     if (!prop)
0281         return NULL;
0282
0283     return strlen(prop) ? prop : NULL;
0284 }
0285
0286 static __init void parse_cmdline(void)
0287 {
0288     const u8 *prop = get_bootargs_cmdline();
0289
0290     if (IS_ENABLED(CONFIG_CMDLINE_FORCE) || !prop)
0291         __parse_cmdline(CONFIG_CMDLINE, true);
0292
0293     if (!IS_ENABLED(CONFIG_CMDLINE_FORCE) && prop)
0294         __parse_cmdline(prop, true);
0295 }
0296
0297 /* Keep checkers quiet */
0298 void init_feature_override(u64 boot_status);
0299
0300 asmlinkage void __init init_feature_override(u64 boot_status)
0301 {
0302     int i;
0303
0304     for (i = 0; i < ARRAY_SIZE(regs); i++) {
0305         if (regs[i]->override) {
0306             regs[i]->override->val  = 0;
0307             regs[i]->override->mask = 0;
0308         }
0309     }
0310
0311     __boot_status = boot_status;
0312
0313     parse_cmdline();
0314
0315     for (i = 0; i < ARRAY_SIZE(regs); i++) {
0316         if (regs[i]->override)
0317             dcache_clean_inval_poc((unsigned long)regs[i]->override,
0318                         (unsigned long)regs[i]->override +
0319                         sizeof(*regs[i]->override));
0320     }
0321 }