Skip to contentSkip to conversation

arm64: errata: Rework Spectre BHB mitigations to not assume "safe"

PATCH Applied Douglas Anderson 4 participants 14 messages Jan 7, 2025 – Mar 14, 2025

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

v4 cover arm64: errata: Rework Spectre BHB mitigations to not assume "safe"

Recently I realized that a device with some Qualcomm Kryo 4xx cores reported in lscpu that it was _not_ vulnerable to Spectre BHB. This seemed unlikely to me.

I wrote up a patch series to attempt (with a lot of guesswork) to add Qualcomm cores to the tables governing how the Spectre BHB mitigation worked.

In response to that patch, Will suggested that I flip the mitigation on its head and assume things are vulnerable until we find that they're not [1]. This patch series _attempts_ to accomplish that.

In case it's not obvious, v2 of this patch series was pretty different than v1 because it flips the logic on its head. Some of the patches carried over, though.

v3 is yet more different, avoiding the guesses (and thus dropping some patches) and also incorporating feedback from Julius in response to v2.

v4 addresses minor feedback plus re-adds Qualcomm cores since I managed to find a contact at Qualcomm to provide confirmation.

As a last caveat, I'll note that I am certainly no expert on Spectre. Mostly I ended up here running lscpu on a device and noticing that it thought that it wasn't affected by Spectre v2 when I thought it was.

Link to prev versions:
v1: https://lore.kernel.org/r/[email protected]/
v2: https://lore.kernel.org/r/[email protected]
v3: https://lore.kernel.org/r/[email protected]

[1] https://lore.kernel.org/r/20241211213410.GB17486@willie-the-truck

Changes in v4:
- Re-added QCOM_KRYO_4XX_GOLD k24 patch after Qualcomm confirmed.
- Add MIDR_BRAHMA_B53 as safe.
- Get rid of spectre_bhb_firmware_mitigated_list.
- Re-added KRYO 2XX/3XX/4XX silver patch after Qualcomm confirmed.

Changes in v3:
- Removed QCOM_KRYO_4XX_GOLD k24 patch.
- Don't guess the mitigation; just report unknown cores as vulnerable.
- Restructure the code since is_spectre_bhb_affected() defaults to true
- Removed KRYO 2XX/3XX/4XX silver patch.
- arm64: cputype: Add MIDR_CORTEX_A76AE
- arm64: errata: Add newer ARM cores to the spectre_bhb_loop_affected() lists

Changes in v2:
- Slight change to wording and notes of KRYO_4XX_GOLD patch
- arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB
- arm64: errata: Add KRYO 2XX/3XX/4XX silver cores to Spectre BHB safe list

Douglas Anderson (5):
arm64: errata: Add QCOM_KRYO_4XX_GOLD to the spectre_bhb_k24_list
arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre
BHB
arm64: errata: Add KRYO 2XX/3XX/4XX silver cores to Spectre BHB safe
list
arm64: cputype: Add MIDR_CORTEX_A76AE
arm64: errata: Add newer ARM cores to the spectre_bhb_loop_affected()
lists

 arch/arm64/include/asm/cputype.h |   2 +
 arch/arm64/include/asm/spectre.h |   1 -
 arch/arm64/kernel/proton-pack.c  | 218 +++++++++++++++++--------------
 3 files changed, 120 insertions(+), 101 deletions(-)
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
#1 lore raw

PATCH v4 1/5 arm64: errata: Add QCOM_KRYO_4XX_GOLD to the spectre_bhb_k24_list

Qualcomm Kryo 400-series Gold cores have a derivative of an ARM Cortex A76 in them. Since A76 needs Spectre mitigation via looping then the Kyro 400-series Gold cores also need Spectre mitigation via looping.

Qualcomm has confirmed that the proper "k" value for Kryo 400-series Gold cores is 24.

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")
Cc Scott Bauer <[email protected]>

---

Changes in v4:
- Re-added QCOM_KRYO_4XX_GOLD k24 patch after Qualcomm confirmed.

Changes in v3:
- Removed QCOM_KRYO_4XX_GOLD k24 patch.

Changes in v2:
- Slight change to wording and notes of KRYO_4XX_GOLD patch

 arch/arm64/kernel/proton-pack.c | 1 +
 1 file changed, 1 insertion(+)
arch/arm64/kernel/proton-pack.c +1 -0
index da53722f95d4..e149efadff20 100644
@@ -866,6 +866,7 @@ u8 spectre_bhb_loop_affected(int scope)
 			MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
 			MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
 			MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
+			MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
 			{},
 		};
 		static const struct midr_range spectre_bhb_k11_list[] = {
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
Acked-by on v4 1/5
#2 lore raw

Re: [PATCH v4 1/5] arm64: errata: Add QCOM_KRYO_4XX_GOLD to the spectre_bhb_k24_list

Quoted 30 lines · Douglas Anderson

Qualcomm Kryo 400-series Gold cores have a derivative of an ARM Cortex A76 in them. Since A76 needs Spectre mitigation via looping then the Kyro 400-series Gold cores also need Spectre mitigation via looping.

Qualcomm has confirmed that the proper "k" value for Kryo 400-series Gold cores is 24.

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")
Cc Scott Bauer <[email protected]>

---

Changes in v4:
- Re-added QCOM_KRYO_4XX_GOLD k24 patch after Qualcomm confirmed.

Changes in v3:
- Removed QCOM_KRYO_4XX_GOLD k24 patch.

Changes in v2:
- Slight change to wording and notes of KRYO_4XX_GOLD patch

 arch/arm64/kernel/proton-pack.c | 1 +
 1 file changed, 1 insertion(+)
arch/arm64/kernel/proton-pack.c +0 -0
index da53722f95d4..e149efadff20 100644

arch/arm64/kernel/proton-pack.c u8 spectre_bhb_loop_affected(int scope) · line 872

Quoted 7 lines
arch/arm64/kernel/proton-pack.c +1 -0
@@ -866,6 +866,7 @@ u8 spectre_bhb_loop_affected(int scope)
 			MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
 			MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
 			MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
+			MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
 			{},
 		};
 		static const struct midr_range spectre_bhb_k11_list[] = {

LGTM. Sorry for the delay.

Signature · 1 line
---Trilok Soni
#3 lore raw

PATCH v4 2/5 arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB

In reply to Douglas Anderson

The code for detecting CPUs that are vulnerable to Spectre BHB was based on a hardcoded list of CPU IDs that were known to be affected. Unfortunately, the list mostly only contained the IDs of standard ARM cores. The IDs for many cores that are minor variants of the standard ARM cores (like many Qualcomm Kyro CPUs) weren't listed. This led the code to assume that those variants were not affected.

Flip the code on its head and instead assume that a core is vulnerable if it doesn't have CSV2_3 but is unrecognized as being safe. This involves creating a "Spectre BHB safe" list.

As of right now, the only CPU IDs added to the "Spectre BHB safe" list are ARM Cortex A35, A53, A55, A510, and A520. This list was created by looking for cores that weren't listed in ARM's list [1] as per review feedback on v2 of this patch [2]. Additionally Brahma A53 is added as per mailing list feedback [3].

NOTE: this patch will not actually _mitigate_ anyone, it will simply cause them to report themselves as vulnerable. If any cores in the system are reported as vulnerable but not mitigated then the whole system will be reported as vulnerable though the system will attempt to mitigate with the information it has about the known cores.

[1] https://developer.arm.com/Arm%20Security%20Center/Spectre-BHB
[2] https://lore.kernel.org/r/20241219175128.GA25477@willie-the-truck
[3] https://lore.kernel.org/r/[email protected]

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")

---

Changes in v4:
- Add MIDR_BRAHMA_B53 as safe.
- Get rid of spectre_bhb_firmware_mitigated_list.

Changes in v3:
- Don't guess the mitigation; just report unknown cores as vulnerable.
- Restructure the code since is_spectre_bhb_affected() defaults to true

Changes in v2:
- New

 arch/arm64/include/asm/spectre.h |   1 -
 arch/arm64/kernel/proton-pack.c  | 203 ++++++++++++++++---------------
 2 files changed, 102 insertions(+), 102 deletions(-)
arch/arm64/include/asm/spectre.h +0 -1
index 0c4d9045c31f..f1524cdeacf1 100644
@@ -97,7 +97,6 @@ enum mitigation_state arm64_get_meltdown_state(void);
 
 enum mitigation_state arm64_get_spectre_bhb_state(void);
 bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, int scope);
-u8 spectre_bhb_loop_affected(int scope);
 void spectre_bhb_enable_mitigation(const struct arm64_cpu_capabilities *__unused);
 bool try_emulate_el1_ssbs(struct pt_regs *regs, u32 instr);
 
arch/arm64/kernel/proton-pack.c +102 -101

266 lines not on this page · raw message

Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
#4 lore raw

Re: [PATCH v4 2/5] arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB

Hi Doug,

Quoted 23 lines · Douglas Anderson

The code for detecting CPUs that are vulnerable to Spectre BHB was based on a hardcoded list of CPU IDs that were known to be affected. Unfortunately, the list mostly only contained the IDs of standard ARM cores. The IDs for many cores that are minor variants of the standard ARM cores (like many Qualcomm Kyro CPUs) weren't listed. This led the code to assume that those variants were not affected.

Flip the code on its head and instead assume that a core is vulnerable if it doesn't have CSV2_3 but is unrecognized as being safe. This involves creating a "Spectre BHB safe" list.

As of right now, the only CPU IDs added to the "Spectre BHB safe" list are ARM Cortex A35, A53, A55, A510, and A520. This list was created by looking for cores that weren't listed in ARM's list [1] as per review feedback on v2 of this patch [2]. Additionally Brahma A53 is added as per mailing list feedback [3].

NOTE: this patch will not actually _mitigate_ anyone, it will simply cause them to report themselves as vulnerable. If any cores in the system are reported as vulnerable but not mitigated then the whole system will be reported as vulnerable though the system will attempt to mitigate with the information it has about the known cores.

Quoted 3 lines

arch/arm64/include/asm/spectre.h | 1 -
arch/arm64/kernel/proton-pack.c | 203 ++++++++++++++++---------------

2 files changed, 102 insertions(+), 102 deletions(-)

This is a pretty hefty diff-stat for adding a list of six CPUs. It looks like there are multiple things going on here: I think you're adding the 'safe' list of CPUs, then removing the list of firmware-mitigated list, then removing some indentation to do the mitigation detection differently. Any chance this can be split up?
(I'm not sure about the last chunk - it breaks automatic backporting)

Quoted 83 lines
arch/arm64/kernel/proton-pack.c +31 -44
index e149efadff20..17aa836fe46d 100644
 
 
+static u8 spectre_bhb_loop_affected(void)
 {
 	u8 k = 0;
-	static u8 max_bhb_k;
-
-	if (scope == SCOPE_LOCAL_CPU) {
-		static const struct midr_range spectre_bhb_k32_list[] = {
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A78),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A78C),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_X1),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A710),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_X2),
-			MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N2),
-			MIDR_ALL_VERSIONS(MIDR_NEOVERSE_V1),
-			{},
-		};
-		static const struct midr_range spectre_bhb_k24_list[] = {
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
-			MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
-			MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
-			{},
-		};
-		static const struct midr_range spectre_bhb_k11_list[] = {
-			MIDR_ALL_VERSIONS(MIDR_AMPERE1),
-			{},
-		};
-		static const struct midr_range spectre_bhb_k8_list[] = {
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
-			MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
-			{},
-		};
-
-		if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))
-			k = 32;
-		else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k24_list))
-			k = 24;
-		else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k11_list))
-			k = 11;
-		else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k8_list))
-			k =  8;
-
-		max_bhb_k = max(max_bhb_k, k);
-	} else {
-		k = max_bhb_k;
-	}
+
+	static const struct midr_range spectre_bhb_k32_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78C),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_X1),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A710),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_X2),
+		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N2),
+		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_V1),
+		{},
+	};
+	static const struct midr_range spectre_bhb_k24_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
+		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
+		{},
+	};
+	static const struct midr_range spectre_bhb_k11_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_AMPERE1),
+		{},
+	};
+	static const struct midr_range spectre_bhb_k8_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
+		{},
+	};
+
+	if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))

arch/arm64/kernel/proton-pack.c static unsigned long system_bhb_mitigations; · line 914

Quoted 10 lines
arch/arm64/kernel/proton-pack.c +7 -0
+		k = 32;
+	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k24_list))
+		k = 24;
+	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k11_list))
+		k = 11;
+	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k8_list))
+		k =  8;
 
 	return k;
 }

This previous hunk reduces the indent to remove the static variable from inside the function. Your patch-1 can be picked up automatically by stable branches, but after this change, that will have to be done by hand. Arm have recently updated that table of CPUs with extra entries (thanks for picking those up!) - but now that patch can't be easily applied to older kernels.
I suspect making the reporting assuming-vulnerable may make other CPUs come out of the wood work too...

Could we avoid changing this unless we really need to?

As background, the idea is that CPUs that are newer than the kernel will discover the need for mitigation from firmware. That sucks for performance, but it can be improved once the kernel is updated to know about the 'local' workaround.

Quoted 17 lines
arch/arm64/kernel/proton-pack.c +2 -4
@@ -955,6 +956,8 @@ static bool supports_ecbhb(int scope)
 						    ID_AA64MMFR1_EL1_ECBHB_SHIFT);
 }
 
+static u8 max_bhb_k;
+
 bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry,
 			     int scope)
 {
@@ -963,16 +966,18 @@ bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry,
 	if (supports_csv2p3(scope))
 		return false;
 
-	if (supports_clearbhb(scope))
-		return true;
-
-	if (spectre_bhb_loop_affected(scope))

arch/arm64/kernel/proton-pack.c bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, · line 975

Quoted 10 lines
arch/arm64/kernel/proton-pack.c +6 -3
-		return true;
+	if (is_spectre_bhb_safe(scope))
+		return false;
 
-	if (is_spectre_bhb_fw_affected(scope))
-		return true;
+	/*
+	 * At this point the core isn't known to be "safe" so we're going to
+	 * assume it's vulnerable. We still need to update `max_bhb_k` though,
+	 * but only if we aren't mitigating with clearbhb though.

+ or firmware.

arch/arm64/kernel/proton-pack.c bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, · line 978

Quoted 3 lines
arch/arm64/kernel/proton-pack.c +3 -0
+	 */
+	if (scope == SCOPE_LOCAL_CPU && !supports_clearbhb(SCOPE_LOCAL_CPU))
+		max_bhb_k = max(max_bhb_k, spectre_bhb_loop_affected());

CPUs that need a firmware mitigation will get in here too. Its probably harmless as they'll report '0' as their k value... but you went to the trouble to weed out the CPUs that support the clearbhb instruction ...

For the change described in the commit message, isn't it enough to replace the final 'return false' with 'return !is_spectre_bhb_safe(scope)' ?

arch/arm64/kernel/proton-pack.c bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, · line 981

Quoted 4 lines
arch/arm64/kernel/proton-pack.c +1 -1
-	return false;
+	return true;
 }

Thanks,

James

#5 lore raw

Re: [PATCH v4 2/5] arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB

Hi,

Quoted 27 lines · James Morse

Hi Doug,

Quoted 22 lines · Douglas Anderson

The code for detecting CPUs that are vulnerable to Spectre BHB was based on a hardcoded list of CPU IDs that were known to be affected. Unfortunately, the list mostly only contained the IDs of standard ARM cores. The IDs for many cores that are minor variants of the standard ARM cores (like many Qualcomm Kyro CPUs) weren't listed. This led the code to assume that those variants were not affected.

Flip the code on its head and instead assume that a core is vulnerable if it doesn't have CSV2_3 but is unrecognized as being safe. This involves creating a "Spectre BHB safe" list.

As of right now, the only CPU IDs added to the "Spectre BHB safe" list are ARM Cortex A35, A53, A55, A510, and A520. This list was created by looking for cores that weren't listed in ARM's list [1] as per review feedback on v2 of this patch [2]. Additionally Brahma A53 is added as per mailing list feedback [3].

NOTE: this patch will not actually _mitigate_ anyone, it will simply cause them to report themselves as vulnerable. If any cores in the system are reported as vulnerable but not mitigated then the whole system will be reported as vulnerable though the system will attempt to mitigate with the information it has about the known cores.

Quoted 8 lines
Quoted 3 lines

arch/arm64/include/asm/spectre.h | 1 -
arch/arm64/kernel/proton-pack.c | 203 ++++++++++++++++---------------

2 files changed, 102 insertions(+), 102 deletions(-)

This is a pretty hefty diff-stat for adding a list of six CPUs. It looks like there are multiple things going on here: I think you're adding the 'safe' list of CPUs, then removing the list of firmware-mitigated list, then removing some indentation to do the mitigation detection differently. Any chance this can be split up?

I have to get back into the headspace of this patch since it's been a few weeks, but let's see.

At the end, you suggest that maybe we could simplify this patch by just adding the function is_spectre_bhb_safe(), calling it at the beginning of is_spectre_bhb_affected(), and then changing is_spectre_bhb_affected() to return "true" at the end instead of false. Looking back at the patch, I believe this is correct.

...that being said, all of the other changes that are part of this patch came in response to review feedback on earlier versions of the patch and do make sense. Specifically:

1. Once the default value is to return false, there's not a reason to call supports_clearbhb() and is_spectre_bhb_fw_affected() in is_spectre_bhb_affected(), right? Those two functions _only_ job was to be able to cause is_spectre_bhb_affected() to sometimes return "true" instead of "false", but the function returns true by default now so the calls have no purpose.

2. After we do #1, it doesn't really make sense to still have the snippet of code that looks like this:

if (spectre_bhb_loop_affected(scope))

    return true;

return true;

We could just change that to:

spectre_bhb_loop_affected(scope)
return true;

...but then it seems really strange to call a function that returns a value and we're ignoring it. As per review feedback on the previous versions, I moved the calculation of "max_bhb_k" out of spectre_bhb_loop_affected() and made that just for local scope and it turned out much cleaner.

3. Given that we no longer have a reason to call is_spectre_bhb_fw_affected() in is_spectre_bhb_affected(), it also made sense to get rid of the "scope" variable for that function and simplify it and the other caller.

...so I could break some of that stuff up into separate patches, but I don't think we'd just want to drop any of the changes.

Quoted 1 line

(I'm not sure about the last chunk - it breaks automatic backporting)

Why would it break things? This entire series should just be backported including the change of the default value to "affected". If someone is running an old "stable" kernel and they're missing a mitigation this would make it more obvious to them. Without backporting everything then people running old kernels but lacking a needed FW mitigation would show as "unaffected" when really they are "vulnerable".

Quoted 91 lines
Quoted 91 lines
arch/arm64/kernel/proton-pack.c +38 -44
index e149efadff20..17aa836fe46d 100644
 
 
+static u8 spectre_bhb_loop_affected(void)
 {
      u8 k = 0;
-     static u8 max_bhb_k;
-
-     if (scope == SCOPE_LOCAL_CPU) {
-             static const struct midr_range spectre_bhb_k32_list[] = {
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A78),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A78C),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_X1),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A710),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_X2),
-                     MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N2),
-                     MIDR_ALL_VERSIONS(MIDR_NEOVERSE_V1),
-                     {},
-             };
-             static const struct midr_range spectre_bhb_k24_list[] = {
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
-                     MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
-                     MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
-                     {},
-             };
-             static const struct midr_range spectre_bhb_k11_list[] = {
-                     MIDR_ALL_VERSIONS(MIDR_AMPERE1),
-                     {},
-             };
-             static const struct midr_range spectre_bhb_k8_list[] = {
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
-                     MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
-                     {},
-             };
-
-             if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))
-                     k = 32;
-             else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k24_list))
-                     k = 24;
-             else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k11_list))
-                     k = 11;
-             else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k8_list))
-                     k =  8;
-
-             max_bhb_k = max(max_bhb_k, k);
-     } else {
-             k = max_bhb_k;
-     }
+
+     static const struct midr_range spectre_bhb_k32_list[] = {
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A78),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A78C),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_X1),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A710),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_X2),
+             MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N2),
+             MIDR_ALL_VERSIONS(MIDR_NEOVERSE_V1),
+             {},
+     };
+     static const struct midr_range spectre_bhb_k24_list[] = {
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
+             MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
+             MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
+             {},
+     };
+     static const struct midr_range spectre_bhb_k11_list[] = {
+             MIDR_ALL_VERSIONS(MIDR_AMPERE1),
+             {},
+     };
+     static const struct midr_range spectre_bhb_k8_list[] = {
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
+             MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
+             {},
+     };
+
+     if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))
+             k = 32;
+     else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k24_list))
+             k = 24;
+     else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k11_list))
+             k = 11;
+     else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k8_list))
+             k =  8;
Quoted 6 lines
Quoted 2 lines
      return k;

}

This previous hunk reduces the indent to remove the static variable from inside the function. Your patch-1 can be picked up automatically by stable branches, but after this change, that will have to be done by hand.

As per above, I think the whole series should simply be backported so this shouldn't be an issue.

Quoted 7 lines

Arm have recently updated that table of CPUs
with extra entries (thanks for picking those up!) - but now that patch can't be easily applied to older kernels.
I suspect making the reporting assuming-vulnerable may make other CPUs come out of the wood work too...

Could we avoid changing this unless we really need to?

Will / Catalin: Do either of you have an opinion here?

Quoted 26 lines

As background, the idea is that CPUs that are newer than the kernel will discover the need for mitigation from firmware. That sucks for performance, but it can be improved once the kernel is updated to know about the 'local' workaround.

Quoted 21 lines
arch/arm64/kernel/proton-pack.c +4 -5
@@ -955,6 +956,8 @@ static bool supports_ecbhb(int scope)
                                                  ID_AA64MMFR1_EL1_ECBHB_SHIFT);
 }
 
+static u8 max_bhb_k;
+
 bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry,
                           int scope)
 {
@@ -963,16 +966,18 @@ bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry,
      if (supports_csv2p3(scope))
              return false;
 
-     if (supports_clearbhb(scope))
-             return true;
-
-     if (spectre_bhb_loop_affected(scope))
-             return true;
+     if (is_spectre_bhb_safe(scope))
+             return false;
 
Quoted 8 lines

arch/arm64/kernel/proton-pack.c bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, · line 975

Quoted 6 lines
arch/arm64/kernel/proton-pack.c +4 -2
-     if (is_spectre_bhb_fw_affected(scope))
-             return true;
+     /*
+      * At this point the core isn't known to be "safe" so we're going to
+      * assume it's vulnerable. We still need to update `max_bhb_k` though,
+      * but only if we aren't mitigating with clearbhb though.

+ or firmware.

No, I believe my comment is correct as-is. The code in spectre_bhb_enable_mitigation() prior to my change prefers a loop mitigation over a firmware mitigation. My patch doesn't change that behavior. So we'll always update max_bhb_k even if there is a FW mitigation that might be in place. Updating it by comparing it to a value that might be 0 is still an "update" in my mind.

If a FW mitigation _is_ needed for a given core then spectre_bhb_loop_affected() should return a "k" of 0. That will fall through to the FW mitigation.

...so in the context of this code here, we always will "update" max_bhb_k regardless of whether there is a firmware mitigation.

Quoted 7 lines

arch/arm64/kernel/proton-pack.c bool is_spectre_bhb_affected(const struct arm64_cpu_capabilities *entry, · line 978

Quoted 3 lines
arch/arm64/kernel/proton-pack.c +3 -0
+      */
+     if (scope == SCOPE_LOCAL_CPU && !supports_clearbhb(SCOPE_LOCAL_CPU))
+             max_bhb_k = max(max_bhb_k, spectre_bhb_loop_affected());

CPUs that need a firmware mitigation will get in here too. Its probably harmless as they'll report '0' as their k value... but you went to the trouble to weed out the CPUs that support the clearbhb instruction ...

In order to understand why the patch does what it does, I got all my understanding of how mitigations should be applied by maintaining the existing behavior of spectre_bhb_enable_mitigation(). Specifically, if a FW mitigation is _needed_ for a given core then it's important that spectre_bhb_loop_affected() return 0. This means that whoever wrote that code assumes that the loop mitigation trumps the FW mitigation.

I don't think there's any other reason for weeding more CPUs out.

Quoted 2 lines

For the change described in the commit message, isn't it enough to replace the final 'return false' with 'return !is_spectre_bhb_safe(scope)' ?

See my response to your first comment.

So I guess in summary I won't plan on sending a v5 at this time and I'd hope that v4 can still land (maybe Qualcomm can give an Ack?). If necessary I could break this patch into more than one to break the diffstat into multiple patches, but I'd prefer to still keep the resulting code the same. I like how it turned out and it matches all the existing review feedback that Julius provided. If Will or Catalin wants to come in or enough other people come in and vote that I should make more changes, then I could do it.

I could move the last two patches up to the front and send a v5 if needed. That would make the short term job of backporting those faster, but any future cores would have the same problem. As per above, I'm of the opinion that the whole series should go to stable for as far back as people are willing to take them (which is why I CCed stable on all the patches)

-Doug

maintainer
#6 lore raw

Re: [PATCH v4 2/5] arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB

Quoted 10 lines · Doug Anderson
Quoted 7 lines · James Morse

Arm have recently updated that table of CPUs
with extra entries (thanks for picking those up!) - but now that patch can't be easily applied to older kernels.
I suspect making the reporting assuming-vulnerable may make other CPUs come out of the wood work too...

Could we avoid changing this unless we really need to?

Will / Catalin: Do either of you have an opinion here?

Is this about whether to report "vulnerable" for unknown CPUs? I think Will suggested this:

https://lore.kernel.org/all/20241219175128.GA25477@willie-the-truck/

That said, some patch splitting will help to make review easier. Should such change be back-portable as well? I think so, it's not only for CPUs we'll see in the future.

Signature · 1 line
Catalin
#7 lore raw

Re: [PATCH v4 2/5] arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB

Hi,

Quoted 9 lines · Catalin Marinas
Quoted 7 lines · Doug Anderson
Quoted 6 lines · James Morse

Arm have recently updated that table of CPUs
with extra entries (thanks for picking those up!) - but now that patch can't be easily applied to older kernels.
I suspect making the reporting assuming-vulnerable may make other CPUs come out of the wood work too...

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

Could we avoid changing this unless we really need to?

Will / Catalin: Do either of you have an opinion here?

Is this about whether to report "vulnerable" for unknown CPUs? I think Will suggested this:

https://lore.kernel.org/all/20241219175128.GA25477@willie-the-truck/

Right. The patch in its current form is in direct response to what Will requested and then subsequent feedback on the mailing lists from Julius Werner.

Quoted 3 lines

That said, some patch splitting will help to make review easier. Should such change be back-portable as well? I think so, it's not only for CPUs we'll see in the future.

Personally, I don't think the patch will be terribly hard to backport as-is. I would expect it to just cherry-pick cleanly since it only touches spectre code and I'd imagine all that stuff is being backported verbatim. I did at least confirm that it applies cleanly to v5.15.178 (I didn't try compiling though). I guess there are conflicts back to v5.10.234, though...

While I've had plenty of time to work on this patch in the last three months since I posted the early versions, recently my assignments at work have changed and I have a lot less time to work on this patch series. If breaking this up is blocking this patch from landing then I'll try to find some time in the next month or two to do it. Let me know.

-Doug

#8 lore raw

PATCH v4 3/5 arm64: errata: Add KRYO 2XX/3XX/4XX silver cores to Spectre BHB safe list

In reply to Douglas Anderson

Qualcomm has confirmed that, much like Cortex A53 and A55, KRYO 2XX/3XX/4XX silver cores are unaffected by Spectre BHB. Add them to the safe list.

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")
Cc Scott Bauer <[email protected]>

---

Changes in v4:
- Re-added KRYO 2XX/3XX/4XX silver patch after Qualcomm confirmed.

Changes in v3:
- Removed KRYO 2XX/3XX/4XX silver patch.

Changes in v2:
- New

 arch/arm64/kernel/proton-pack.c | 3 +++
 1 file changed, 3 insertions(+)
arch/arm64/kernel/proton-pack.c +3 -0
index 17aa836fe46d..89405be53d8f 100644
@@ -854,6 +854,9 @@ static bool is_spectre_bhb_safe(int scope)
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A510),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A520),
 		MIDR_ALL_VERSIONS(MIDR_BRAHMA_B53),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_2XX_SILVER),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_3XX_SILVER),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_SILVER),
 		{},
 	};
 	static bool all_safe = true;
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
Acked-by on v4 3/5
#9 lore raw

Re: [PATCH v4 3/5] arm64: errata: Add KRYO 2XX/3XX/4XX silver cores to Spectre BHB safe list

Quoted 28 lines · Douglas Anderson

Qualcomm has confirmed that, much like Cortex A53 and A55, KRYO 2XX/3XX/4XX silver cores are unaffected by Spectre BHB. Add them to the safe list.

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")
Cc Scott Bauer <[email protected]>

---

Changes in v4:
- Re-added KRYO 2XX/3XX/4XX silver patch after Qualcomm confirmed.

Changes in v3:
- Removed KRYO 2XX/3XX/4XX silver patch.

Changes in v2:
- New

 arch/arm64/kernel/proton-pack.c | 3 +++
 1 file changed, 3 insertions(+)
arch/arm64/kernel/proton-pack.c +0 -0
index 17aa836fe46d..89405be53d8f 100644

arch/arm64/kernel/proton-pack.c static bool is_spectre_bhb_safe(int scope) · line 862

Quoted 9 lines
arch/arm64/kernel/proton-pack.c +3 -0
@@ -854,6 +854,9 @@ static bool is_spectre_bhb_safe(int scope)
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A510),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A520),
 		MIDR_ALL_VERSIONS(MIDR_BRAHMA_B53),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_2XX_SILVER),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_3XX_SILVER),
+		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_SILVER),
 		{},
 	};
 	static bool all_safe = true;
Signature · 1 line
---Trilok Soni
#10 lore raw

PATCH v4 4/5 arm64: cputype: Add MIDR_CORTEX_A76AE

In reply to Douglas Anderson

From the TRM, MIDR_CORTEX_A76AE has a partnum of 0xDOE and an implementor of 0x41 (ARM). Add the values.

Cc [email protected] # dependency of the next fix in the series

---

(no changes since v3)

Changes in v3:
- New

 arch/arm64/include/asm/cputype.h | 2 ++
 1 file changed, 2 insertions(+)
arch/arm64/include/asm/cputype.h +2 -0
index 488f8e751349..a345628fce51 100644
@@ -75,6 +75,7 @@
 #define ARM_CPU_PART_CORTEX_A76		0xD0B
 #define ARM_CPU_PART_NEOVERSE_N1	0xD0C
 #define ARM_CPU_PART_CORTEX_A77		0xD0D
+#define ARM_CPU_PART_CORTEX_A76AE	0xD0E
 #define ARM_CPU_PART_NEOVERSE_V1	0xD40
 #define ARM_CPU_PART_CORTEX_A78		0xD41
 #define ARM_CPU_PART_CORTEX_A78AE	0xD42
@@ -158,6 +159,7 @@
 #define MIDR_CORTEX_A76	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A76)
 #define MIDR_NEOVERSE_N1 MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_NEOVERSE_N1)
 #define MIDR_CORTEX_A77	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A77)
+#define MIDR_CORTEX_A76AE	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A76AE)
 #define MIDR_NEOVERSE_V1	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_NEOVERSE_V1)
 #define MIDR_CORTEX_A78	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A78)
 #define MIDR_CORTEX_A78AE	MIDR_CPU_MODEL(ARM_CPU_IMP_ARM, ARM_CPU_PART_CORTEX_A78AE)
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
#11 lore raw

PATCH v4 5/5 arm64: errata: Add newer ARM cores to the spectre_bhb_loop_affected() lists

In reply to Douglas Anderson

When comparing to the ARM list [1], it appears that several ARM cores were missing from the lists in spectre_bhb_loop_affected(). Add them.

NOTE: for some of these cores it may not matter since other ways of clearing the BHB may be used (like the CLRBHB instruction or ECBHB), but it still seems good to have all the info from ARM's whitepaper included.

[1] https://developer.arm.com/Arm%20Security%20Center/Spectre-BHB

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")

---

(no changes since v3)

Changes in v3:
- New

 arch/arm64/kernel/proton-pack.c | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)
arch/arm64/kernel/proton-pack.c +14 -1
index 89405be53d8f..0f51fd10b4b0 100644
@@ -876,6 +876,14 @@ static u8 spectre_bhb_loop_affected(void)
 {
 	u8 k = 0;
 
+	static const struct midr_range spectre_bhb_k132_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_X3),
+		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_V2),
+	};
+	static const struct midr_range spectre_bhb_k38_list[] = {
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A715),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A720),
+	};
 	static const struct midr_range spectre_bhb_k32_list[] = {
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A78AE),
@@ -889,6 +897,7 @@ static u8 spectre_bhb_loop_affected(void)
 	};
 	static const struct midr_range spectre_bhb_k24_list[] = {
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A76),
+		MIDR_ALL_VERSIONS(MIDR_CORTEX_A76AE),
 		MIDR_ALL_VERSIONS(MIDR_CORTEX_A77),
 		MIDR_ALL_VERSIONS(MIDR_NEOVERSE_N1),
 		MIDR_ALL_VERSIONS(MIDR_QCOM_KRYO_4XX_GOLD),
@@ -904,7 +913,11 @@ static u8 spectre_bhb_loop_affected(void)
 		{},
 	};
 
-	if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))
+	if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k132_list))
+		k = 132;
+	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k38_list))
+		k = 38;
+	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k32_list))
 		k = 32;
 	else if (is_midr_in_range_list(read_cpuid_id(), spectre_bhb_k24_list))
 		k = 24;
Signature · 1 line
2.47.1.613.gc27f4b7a9f-goog
Reviewed-by on v4 5/5
#12 lore raw

Re: [PATCH v4 5/5] arm64: errata: Add newer ARM cores to the spectre_bhb_loop_affected() lists

Hi Doug,

Quoted 2 lines · Douglas Anderson

When comparing to the ARM list [1], it appears that several ARM cores were missing from the lists in spectre_bhb_loop_affected(). Add them.

It's a moving target!

Quoted 10 lines

NOTE: for some of these cores it may not matter since other ways of clearing the BHB may be used (like the CLRBHB instruction or ECBHB), but it still seems good to have all the info from ARM's whitepaper included.

[1] https://developer.arm.com/Arm%20Security%20Center/Spectre-BHB

Fixes 558c303c9734 ("arm64: Mitigate spectre style branch history side channels")

Thanks!

James

maintainer Applied
#13 lore raw
In reply to Douglas Anderson
Quoted 9 lines · Douglas Anderson

Recently I realized that a device with some Qualcomm Kryo 4xx cores reported in lscpu that it was _not_ vulnerable to Spectre BHB. This seemed unlikely to me.

I wrote up a patch series to attempt (with a lot of guesswork) to add Qualcomm cores to the tables governing how the Spectre BHB mitigation worked.

[...]

Applied to arm64 (for-next/spectre-bhb-assume-vulnerable), thanks!

As per Will's suggestion at the end of last year:

https://lore.kernel.org/r/20241219175128.GA25477@willie-the-truck/

Doug has reworked the code to assume vulnerable by default. James did suggest some splitting of patch 2 but given that Doug doesn't have time for a respin I decided to queue the patches. If anyone has a strong opinion, please let me know (and reworking the series is welcomed).

[1/5] arm64: errata: Add QCOM_KRYO_4XX_GOLD to the spectre_bhb_k24_list

      https://git.kernel.org/arm64/c/ed1ce841245d
[2/5] arm64: errata: Assume that unknown CPUs _are_ vulnerable to Spectre BHB
      https://git.kernel.org/arm64/c/e403e8538359
[3/5] arm64: errata: Add KRYO 2XX/3XX/4XX silver cores to Spectre BHB safe list
      https://git.kernel.org/arm64/c/0c9fc6e652cd
[4/5] arm64: cputype: Add MIDR_CORTEX_A76AE
      https://git.kernel.org/arm64/c/a9b5bd81b294
[5/5] arm64: errata: Add newer ARM cores to the spectre_bhb_loop_affected() lists
      https://git.kernel.org/arm64/c/a5951389e58d
Signature · 1 line
Catalin