x86/microcode: Do not taint when late loading on AMD
Subsystems (3)
Borislav Petkov
maintainerPATCH 1/1 x86/microcode: Do not taint when late loading on AMD
From: "Borislav Petkov (AMD)" <[email protected]>
Describe why the concurrency issues which late loading poses are not affecting AMD hardware, after discussing it with hw folks. Thus, do not taint when late loading on it.
--- Documentation/x86/microcode.rst | 10 ++++++++++ arch/x86/kernel/cpu/microcode/core.c | 3 ++- 2 files changed, 12 insertions(+), 1 deletion(-)
Documentation/x86/microcode.rst +10 -0
@@ -208,6 +208,16 @@ Basically there is no way to declare a new microcode update suitable for late-loading. This is another one of the problems that caused late loading to be not enabled by default. +AMD +--- + +Late loading on AMD does not have the concurrency issues described +above: when loading is attempted on T0, the T1 is quiesced and does not +execute instructions. Therefore, even if a higher priority interrupt or +a fault happens, the whole core will see it either before the microcode +patch has been applied or after. In either case, T0 and T1 will have the +same microcode revision and nothing intermediate. + Builtin microcode =================
arch/x86/kernel/cpu/microcode/core.c +2 -1
@@ -498,7 +498,8 @@ static ssize_t reload_store(struct device *dev,if (ret ==0 ) ret = size; -add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); +if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) +add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK );return ret; }
Signature · 1 line
2.35.1
The following commit has been merged into the x86/microcode branch of tip:
The following commit has been merged into the x86/microcode branch of tip:
Commit-ID: 09b951476df9eadf15f2acba7568fa35e4b2313b Gitweb: https://git.kernel.org/tip/09b951476df9eadf15f2acba7568fa35e4b2313b Author: Borislav Petkov (AMD) <[email protected]> AuthorDate: Fri, 03 Mar 2023 12:46:49 +01:00 Committer: Borislav Petkov (AMD) <[email protected]> CommitterDate: Sun, 12 Mar 2023 21:32:51 +01:00
x86/microcode: Do not taint when late loading on AMD
Describe why the concurrency issues which late loading poses are not affecting AMD hardware, after discussing it with hw folks. Thus, do not taint when late loading on it.
--- Documentation/x86/microcode.rst | 10 ++++++++++ arch/x86/kernel/cpu/microcode/core.c | 3 ++- 2 files changed, 12 insertions(+), 1 deletion(-)
Documentation/x86/microcode.rst +10 -0
@@ -208,6 +208,16 @@ Basically there is no way to declare a new microcode update suitable for late-loading. This is another one of the problems that caused late loading to be not enabled by default. +AMD +--- + +Late loading on AMD does not have the concurrency issues described +above: when loading is attempted on T0, the T1 is quiesced and does not +execute instructions. Therefore, even if a higher priority interrupt or +a fault happens, the whole core will see it either before the microcode +patch has been applied or after. In either case, T0 and T1 will have the +same microcode revision and nothing intermediate. + Builtin microcode =================
arch/x86/kernel/cpu/microcode/core.c +2 -1
@@ -498,7 +498,8 @@ put:if (ret ==0 ) ret = size; -add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); +if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) +add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK );return ret; }
Borislav Petkov
maintainerQuoted 9 lines · On Sun, Mar 12, 2023 at 08:47:36PM -0000, tip-bot2 for Borislav Petkov (AMD)…
The following commit has been merged into the x86/microcode branch of tip:
Commit-ID: 09b951476df9eadf15f2acba7568fa35e4b2313b Gitweb: https://git.kernel.org/tip/09b951476df9eadf15f2acba7568fa35e4b2313b Author: Borislav Petkov (AMD) <[email protected]> AuthorDate: Fri, 03 Mar 2023 12:46:49 +01:00 Committer: Borislav Petkov (AMD) <[email protected]> CommitterDate: Sun, 12 Mar 2023 21:32:51 +01:00
Quoted 8 lines
x86/microcode: Do not taint when late loading on AMD
Describe why the concurrency issues which late loading poses are not affecting AMD hardware, after discussing it with hw folks. Thus, do not taint when late loading on it.
Forgot to adjust the error message too. Updated patch coming up.
arch/x86/kernel/cpu/microcode/core.c +4 -4
@@ -440,9 +440,6 @@ static int microcode_reload_late(void)int old = boot_cpu_data.microcode, ret;struct cpuinfo_x86 prev_info; -pr_err ("Attempting late microcode loading - it is dangerous and taints the kernel.\n" ); -pr_err ("You should switch to early loading, if possible.\n" ); -atomic_set (&late_cpus_in,0 );atomic_set (&late_cpus_out,0 );
@@ -498,8 +495,11 @@ static ssize_t reload_store(struct device *dev,if (ret ==0 ) ret = size; -if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) +if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) { +pr_err ("Late microcode loading is dangerous and taints the kernel.\n" ); +pr_err ("You should switch to early loading if possible.\n" );add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); + }return ret; }
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteBorislav Petkov
maintainerPATCH 1/1 x86/microcode: Do not taint when late loading on AMD
From: "Borislav Petkov (AMD)" <[email protected]>
Describe why the concurrency issues which late loading poses are not affecting AMD hardware, after discussing it with hw folks. Thus, do not taint when late loading on it.
--- Documentation/x86/microcode.rst | 10 ++++++++++ arch/x86/kernel/cpu/microcode/core.c | 9 +++++---- 2 files changed, 15 insertions(+), 4 deletions(-)
Documentation/x86/microcode.rst +10 -0
@@ -208,6 +208,16 @@ Basically there is no way to declare a new microcode update suitable for late-loading. This is another one of the problems that caused late loading to be not enabled by default. +AMD +--- + +Late loading on AMD does not have the concurrency issues described +above: when loading is attempted on T0, the T1 is quiesced and does not +execute instructions. Therefore, even if a higher priority interrupt or +a fault happens, the whole core will see it either before the microcode +patch has been applied or after. In either case, T0 and T1 will have the +same microcode revision and nothing intermediate. + Builtin microcode =================
arch/x86/kernel/cpu/microcode/core.c +5 -4
@@ -440,9 +440,6 @@ static int microcode_reload_late(void)int old = boot_cpu_data.microcode, ret;struct cpuinfo_x86 prev_info; -pr_err ("Attempting late microcode loading - it is dangerous and taints the kernel.\n" ); -pr_err ("You should switch to early loading, if possible.\n" ); -atomic_set (&late_cpus_in,0 );atomic_set (&late_cpus_out,0 );
@@ -498,7 +495,11 @@ static ssize_t reload_store(struct device *dev,if (ret ==0 ) ret = size; -add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); +if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) { +pr_err ("Late microcode loading is dangerous and taints the kernel.\n" ); +pr_err ("You should switch to early loading if possible.\n" ); +add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); + }return ret; }
Signature · 1 line
2.35.1
The following commit has been merged into the x86/microcode branch of tip:
The following commit has been merged into the x86/microcode branch of tip:
Commit-ID: 7bc9c1df89a3e5496ace55c198ff09409da0feb0 Gitweb: https://git.kernel.org/tip/7bc9c1df89a3e5496ace55c198ff09409da0feb0 Author: Borislav Petkov (AMD) <[email protected]> AuthorDate: Fri, 03 Mar 2023 12:46:49 +01:00 Committer: Borislav Petkov (AMD) <[email protected]> CommitterDate: Fri, 14 Apr 2023 12:27:36 +02:00
x86/microcode: Do not taint when late loading on AMD
Describe why the concurrency issues which late loading poses are not affecting AMD hardware, after discussing it with hw folks. Thus, do not taint when late loading on it.
--- Documentation/x86/microcode.rst | 10 ++++++++++ arch/x86/kernel/cpu/microcode/core.c | 9 +++++---- 2 files changed, 15 insertions(+), 4 deletions(-)
Documentation/x86/microcode.rst +10 -0
@@ -208,6 +208,16 @@ Basically there is no way to declare a new microcode update suitable for late-loading. This is another one of the problems that caused late loading to be not enabled by default. +AMD +--- + +Late loading on AMD does not have the concurrency issues described +above: when loading is attempted on T0, the T1 is quiesced and does not +execute instructions. Therefore, even if a higher priority interrupt or +a fault happens, the whole core will see it either before the microcode +patch has been applied or after. In either case, T0 and T1 will have the +same microcode revision and nothing intermediate. + Builtin microcode =================
arch/x86/kernel/cpu/microcode/core.c +5 -4
@@ -440,9 +440,6 @@ static int microcode_reload_late(void)int old = boot_cpu_data.microcode, ret;struct cpuinfo_x86 prev_info; -pr_err ("Attempting late microcode loading - it is dangerous and taints the kernel.\n" ); -pr_err ("You should switch to early loading, if possible.\n" ); -atomic_set (&late_cpus_in,0 );atomic_set (&late_cpus_out,0 );
@@ -498,7 +495,11 @@ put:if (ret ==0 ) ret = size; -add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); +if (boot_cpu_data.x86_vendor !=X86_VENDOR_AMD ) { +pr_err ("Late microcode loading is dangerous and taints the kernel.\n" ); +pr_err ("You should switch to early loading if possible.\n" ); +add_taint (TAINT_CPU_OUT_OF_SPEC ,LOCKDEP_STILL_OK ); + }return ret; }