x86/microcode: Early load microcode
Subsystems (4)
v5 cover x86/microcode: Early load microcode
From: Fenghua Yu <[email protected]>
The problem in current microcode loading method is that we load a microcode way, way too late; ideally we should load it before turning paging on. This may only be practical on 32 bits since we can't get to 64-bit mode without paging on, but we should still do it as early as at all possible.
Similarly, we should load the microcode update as early as possible during AP bringup and when processors are brought back online after hotplug or S3/S4.
In order to do that, the microcode patch needs to be permanently present in kernel memory. Each individual patch is fairly small, so that is OK, but the entire blob with support for each CPU is too big. Since only CPU's with same model can be in the same platform, we store microcode with the same model as BSP. Later on APs can upload microcode from the saved microcodep patches.
Note, however, that Linux users have gotten used to being able to install a microcode patch in the field without having a reboot; we support that model too.
In x86_64, this patchset needs early #PF handler set page table patchset. So this patchset is based on:git://git.kernel.org/pub/scm/linux/kernel/git/yinghai/linux-yinghai.git for-x86-boot
v5: Call 64 bit load_ucode_bsp() after copy_bootdata() and remove its parameter.
v4: Change CPUID_IS macro. Call load_ucode_bsp after load_idt in x86_64. Flush tlb after applying microcode.
v3: Change .hex to .bin in 01/10 and 05/10 patches. Fix some compilation warnings. In x86_32 mode, access global varialbes by __pa_symobl() and fix static string issue in x86_vendor(). Call load_ucode_ap() in real mode as well. Add debug info.
v2: Detect vendor before loading microcode. Move some functions from microcode_intel_early.c to microcode_intel_lib.c. Change some early loading microcode dependencies in Kconfig. Reword doc.
Fenghua Yu (12):
Documentation/x86: Early load microcode x86/microcode_intel.h: Define functions and macros for early loading
ucode
x86/common.c: Make have_cpuid_p() a global function x86/common.c: load ucode in 64 bit or show loading ucode info in 32
bit on AP
x86/microcode_core_early.c: Define interfaces for early loading ucode x86/microcode_intel_lib.c: Early update ucode on Intel's CPU x86/tlbflush.h: Define __native_flush_tlb_global_irq_disabled() x86/microcode_intel_early.c: Early update ucode on Intel's CPU x86/head_32.S: Early update ucode in 32-bit
x86/head64.c: Early update ucode in 64-bit
x86/mm/init.c: Copy ucode from initrd image to kernel memory x86/Kconfig: Configurations to enable/disable the feature
Documentation/x86/early-microcode.txt | 43 ++ arch/x86/Kconfig | 18 + arch/x86/include/asm/microcode.h | 14 + arch/x86/include/asm/microcode_intel.h | 85 ++++ arch/x86/include/asm/processor.h | 8 + arch/x86/include/asm/tlbflush.h | 18 +- arch/x86/kernel/Makefile | 3 + arch/x86/kernel/cpu/common.c | 17 +- arch/x86/kernel/head64.c | 6 + arch/x86/kernel/head_32.S | 11 + arch/x86/kernel/microcode_core.c | 7 +- arch/x86/kernel/microcode_core_early.c | 76 +++ arch/x86/kernel/microcode_intel.c | 198 ++------ arch/x86/kernel/microcode_intel_early.c | 796 ++++++++++++++++++++++++++++++++ arch/x86/kernel/microcode_intel_lib.c | 174 +++++++ arch/x86/mm/init.c | 10 + 16 files changed, 1301 insertions(+), 183 deletions(-) create mode 100644 Documentation/x86/early-microcode.txt create mode 100644 arch/x86/include/asm/microcode_intel.h create mode 100644 arch/x86/kernel/microcode_core_early.c create mode 100644 arch/x86/kernel/microcode_intel_early.c create mode 100644 arch/x86/kernel/microcode_intel_lib.c
Signature · 1 line
1.8.0.1
PATCH v5 1/12 Documentation/x86: Early load microcode
From: Fenghua Yu <[email protected]>
Documenation for early loading microcode methodology.
--- Documentation/x86/early-microcode.txt | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Documentation/x86/early-microcode.txt
Documentation/x86/early-microcode.txt new file +43 -0
@@ -0,0 +1,43 @@ +Early load microcode +==================== +By Fenghua Yu <[email protected]> + +Kernel can update microcode in early phase of boot time. Loading microcode early +can fix CPU issues before they are observed during kernel boot time. + +Microcode is stored in an initrd file. The microcode is read from the initrd +file and loaded to CPUs during boot time. + +The format of the combined initrd image is microcode in cpio format followed by +the initrd image (maybe compressed). Kernel parses the combined initrd image +during boot time. The microcode file in cpio name space is: +kernel/x86/microcode/GenuineIntel.bin + +During BSP boot (before SMP starts), if the kernel finds the microcode file in +the initrd file, it parses the microcode and saves matching microcode in memory. +If matching microcode is found, it will be uploaded in BSP and later on in all +APs. + +The cached microcode patch is applied when CPUs resume from a sleep state. + +There are two legacy user space interfaces to load microcode, either through +/dev/cpu/microcode or through /sys/devices/system/cpu/microcode/reload file +in sysfs. + +In addition to these two legacy methods, the early loading method described +here is the third method with which microcode can be uploaded to a system's +CPUs. + +The following example script shows how to generate a new combined initrd file in +/boot/initrd-3.5.0.ucode.img with original microcode microcode.bin and +original initrd image /boot/initrd-3.5.0.img. + +mkdir initrd +cd initrd +mkdir kernel +mkdir kernel/x86 +mkdir kernel/x86/microcode +cp ../microcode.bin kernel/x86/microcode/GenuineIntel.bin +find .|cpio -oc >../ucode.cpio +cd .. +cat ucode.cpio /boot/initrd-3.5.0.img >/boot/initrd-3.5.0.ucode.img
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86, doc: Documentation for early microcode loading
Commit-ID: 0d91ea86a895b911fd7d999acb3f600706d9c8cd Gitweb: http://git.kernel.org/tip/0d91ea86a895b911fd7d999acb3f600706d9c8cd Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:21 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:18:47 -0800
x86, doc: Documentation for early microcode loading
Documenation for early loading microcode methodology.
--- Documentation/x86/early-microcode.txt | 43 +++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+)
Documentation/x86/early-microcode.txt new file +43 -0
@@ -0,0 +1,43 @@ +Early load microcode +==================== +By Fenghua Yu <[email protected]> + +Kernel can update microcode in early phase of boot time. Loading microcode early +can fix CPU issues before they are observed during kernel boot time. + +Microcode is stored in an initrd file. The microcode is read from the initrd +file and loaded to CPUs during boot time. + +The format of the combined initrd image is microcode in cpio format followed by +the initrd image (maybe compressed). Kernel parses the combined initrd image +during boot time. The microcode file in cpio name space is: +kernel/x86/microcode/GenuineIntel.bin + +During BSP boot (before SMP starts), if the kernel finds the microcode file in +the initrd file, it parses the microcode and saves matching microcode in memory. +If matching microcode is found, it will be uploaded in BSP and later on in all +APs. + +The cached microcode patch is applied when CPUs resume from a sleep state. + +There are two legacy user space interfaces to load microcode, either through +/dev/cpu/microcode or through /sys/devices/system/cpu/microcode/reload file +in sysfs. + +In addition to these two legacy methods, the early loading method described +here is the third method with which microcode can be uploaded to a system's +CPUs. + +The following example script shows how to generate a new combined initrd file in +/boot/initrd-3.5.0.ucode.img with original microcode microcode.bin and +original initrd image /boot/initrd-3.5.0.img. + +mkdir initrd +cd initrd +mkdir kernel +mkdir kernel/x86 +mkdir kernel/x86/microcode +cp ../microcode.bin kernel/x86/microcode/GenuineIntel.bin +find .|cpio -oc >../ucode.cpio +cd .. +cat ucode.cpio /boot/initrd-3.5.0.img >/boot/initrd-3.5.0.ucode.img
PATCH v5 2/12 x86/microcode_intel.h: Define functions and macros for early loading ucode
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Define some functions and macros that will be used in early loading ucode. Some of them are moved from microcode_intel.c driver in order to be called in early boot phase before module can be called.
--- arch/x86/include/asm/microcode_intel.h | 85 ++++++++++++++ arch/x86/kernel/Makefile | 3 + arch/x86/kernel/microcode_core.c | 7 +- arch/x86/kernel/microcode_intel.c | 198 +++++---------------------------- 4 files changed, 122 insertions(+), 171 deletions(-) create mode 100644 arch/x86/include/asm/microcode_intel.h
arch/x86/include/asm/microcode_intel.h new file +85 -0
@@ -0,0 +1,85 @@ +#ifndef _ASM_X86_MICROCODE_INTEL_H +#define _ASM_X86_MICROCODE_INTEL_H + +#include <asm/microcode.h> + +struct microcode_header_intel { +unsigned int hdrver; +unsigned int rev; +unsigned int date; +unsigned int sig; +unsigned int cksum; +unsigned int ldrver; +unsigned int pf; +unsigned int datasize; +unsigned int totalsize; +unsigned int reserved[3 ]; +}; + +struct microcode_intel { +struct microcode_header_intel hdr; +unsigned int bits[0 ]; +}; + +/* microcode format is extended from prescott processors */ +struct extended_signature { +unsigned int sig; +unsigned int pf; +unsigned int cksum; +}; + +struct extended_sigtable { +unsigned int count; +unsigned int cksum; +unsigned int reserved[3 ]; +struct extended_signature sigs[0 ]; +}; + +#define DEFAULT_UCODE_DATASIZE (2000) +#define MC_HEADER_SIZE (sizeof(struct microcode_header_intel)) +#define DEFAULT_UCODE_TOTALSIZE (DEFAULT_UCODE_DATASIZE + MC_HEADER_SIZE) +#define EXT_HEADER_SIZE (sizeof(struct extended_sigtable)) +#define EXT_SIGNATURE_SIZE (sizeof(struct extended_signature)) +#define DWSIZE (sizeof(u32)) + +#define get_totalsize (mc) \ + (((struct microcode_intel *)mc)->hdr.totalsize ? \ + ((struct microcode_intel *)mc)->hdr.totalsize : \ + DEFAULT_UCODE_TOTALSIZE) + +#define get_datasize (mc) \ + (((struct microcode_intel *)mc)->hdr.datasize ? \ + ((struct microcode_intel *)mc)->hdr.datasize : DEFAULT_UCODE_DATASIZE) + +#define sigmatch (s1, s2, p1, p2) \ + (((s1) == (s2)) && (((p1) & (p2)) || (((p1) == 0) && ((p2) == 0)))) + +#define exttable_size (et) ((et)->count * EXT_SIGNATURE_SIZE + EXT_HEADER_SIZE) + +extern int +get_matching_microcode (unsigned int csig,int cpf,void *mc,int rev); +extern int microcode_sanity_check (void *mc,int print_err); +extern int get_matching_sig (unsigned int csig,int cpf,void *mc,int rev); +extern int +update_match_revision (struct microcode_header_intel *mc_header,int rev); + +#ifdef CONFIG_MICROCODE_INTEL_EARLY +extern void __init load_ucode_intel_bsp (void ); +extern void __cpuinit load_ucode_intel_ap (void ); +extern void show_ucode_info_early (void ); +#else +static inline __init void load_ucode_intel_bsp (void ) {} +static inline __cpuinit void load_ucode_intel_ap (void ) {} +static inline void show_ucode_info_early (void ) {} +#endif + +#if defined(CONFIG_MICROCODE_INTEL_EARLY ) && defined(CONFIG_HOTPLUG_CPU ) +extern int save_mc_for_early (u8 *mc); +#else +static inline int save_mc_for_early (u8 *mc) +{ +return 0 ; +} +#endif + +#endif /* _ASM_X86_MICROCODE_INTEL_H */
arch/x86/kernel/Makefile +3 -0
@@ -88,6 +88,9 @@ obj-$(CONFIG_PARAVIRT_CLOCK) += pvclock.o obj-$(CONFIG_PCSPKR_PLATFORM) += pcspeaker.o +obj-$(CONFIG_MICROCODE_EARLY) += microcode_core_early.o +obj-$(CONFIG_MICROCODE_INTEL_EARLY) += microcode_intel_early.o +obj-$(CONFIG_MICROCODE_INTEL_LIB) += microcode_intel_lib.o microcode-y := microcode_core.o microcode-$(CONFIG_MICROCODE_INTEL) += microcode_intel.o microcode-$(CONFIG_MICROCODE_AMD) += microcode_amd.o
arch/x86/kernel/microcode_core.c +4 -3
@@ -364,10 +364,7 @@ static struct attribute_group mc_attr_group = {static void microcode_fini_cpu (int cpu) { -struct ucode_cpu_info *uci = ucode_cpu_info + cpu; - microcode_ops->microcode_fini_cpu (cpu); - uci->valid =0 ; }static enum ucode_state microcode_resume_cpu (int cpu)
@@ -383,6 +380,10 @@ static enum ucode_state microcode_resume_cpu(int cpu)static enum ucode_state microcode_init_cpu (int cpu,bool refresh_fw) {enum ucode_state ustate; +struct ucode_cpu_info *uci = ucode_cpu_info + cpu; + +if (uci && uci->valid) +return UCODE_OK ;if (collect_cpu_info (cpu))return UCODE_ERROR ;
arch/x86/kernel/microcode_intel.c +30 -168
253 lines not on this page · raw message
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/microcode_intel.h: Define functions and macros for early loading ucode
Commit-ID: 9cd4d78e21cfdc709b1af516214ec4f69ee0e6bd Gitweb: http://git.kernel.org/tip/9cd4d78e21cfdc709b1af516214ec4f69ee0e6bd Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:22 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:18:50 -0800
x86/microcode_intel.h: Define functions and macros for early loading ucode
Define some functions and macros that will be used in early loading ucode. Some of them are moved from microcode_intel.c driver in order to be called in early boot phase before module can be called.
--- arch/x86/include/asm/microcode_intel.h | 85 ++++++++++++++ arch/x86/kernel/Makefile | 3 + arch/x86/kernel/microcode_core.c | 7 +- arch/x86/kernel/microcode_intel.c | 198 +++++---------------------------- 4 files changed, 122 insertions(+), 171 deletions(-)
arch/x86/include/asm/microcode_intel.h new file +85 -0
@@ -0,0 +1,85 @@ +#ifndef _ASM_X86_MICROCODE_INTEL_H +#define _ASM_X86_MICROCODE_INTEL_H + +#include <asm/microcode.h> + +struct microcode_header_intel { +unsigned int hdrver; +unsigned int rev; +unsigned int date; +unsigned int sig; +unsigned int cksum; +unsigned int ldrver; +unsigned int pf; +unsigned int datasize; +unsigned int totalsize; +unsigned int reserved[3 ]; +}; + +struct microcode_intel { +struct microcode_header_intel hdr; +unsigned int bits[0 ]; +}; + +/* microcode format is extended from prescott processors */ +struct extended_signature { +unsigned int sig; +unsigned int pf; +unsigned int cksum; +}; + +struct extended_sigtable { +unsigned int count; +unsigned int cksum; +unsigned int reserved[3 ]; +struct extended_signature sigs[0 ]; +}; + +#define DEFAULT_UCODE_DATASIZE (2000) +#define MC_HEADER_SIZE (sizeof(struct microcode_header_intel)) +#define DEFAULT_UCODE_TOTALSIZE (DEFAULT_UCODE_DATASIZE + MC_HEADER_SIZE) +#define EXT_HEADER_SIZE (sizeof(struct extended_sigtable)) +#define EXT_SIGNATURE_SIZE (sizeof(struct extended_signature)) +#define DWSIZE (sizeof(u32)) + +#define get_totalsize (mc) \ + (((struct microcode_intel *)mc)->hdr.totalsize ? \ + ((struct microcode_intel *)mc)->hdr.totalsize : \ + DEFAULT_UCODE_TOTALSIZE) + +#define get_datasize (mc) \ + (((struct microcode_intel *)mc)->hdr.datasize ? \ + ((struct microcode_intel *)mc)->hdr.datasize : DEFAULT_UCODE_DATASIZE) + +#define sigmatch (s1, s2, p1, p2) \ + (((s1) == (s2)) && (((p1) & (p2)) || (((p1) == 0) && ((p2) == 0)))) + +#define exttable_size (et) ((et)->count * EXT_SIGNATURE_SIZE + EXT_HEADER_SIZE) + +extern int +get_matching_microcode (unsigned int csig,int cpf,void *mc,int rev); +extern int microcode_sanity_check (void *mc,int print_err); +extern int get_matching_sig (unsigned int csig,int cpf,void *mc,int rev); +extern int +update_match_revision (struct microcode_header_intel *mc_header,int rev); + +#ifdef CONFIG_MICROCODE_INTEL_EARLY +extern void __init load_ucode_intel_bsp (void ); +extern void __cpuinit load_ucode_intel_ap (void ); +extern void show_ucode_info_early (void ); +#else +static inline __init void load_ucode_intel_bsp (void ) {} +static inline __cpuinit void load_ucode_intel_ap (void ) {} +static inline void show_ucode_info_early (void ) {} +#endif + +#if defined(CONFIG_MICROCODE_INTEL_EARLY ) && defined(CONFIG_HOTPLUG_CPU ) +extern int save_mc_for_early (u8 *mc); +#else +static inline int save_mc_for_early (u8 *mc) +{ +return 0 ; +} +#endif + +#endif /* _ASM_X86_MICROCODE_INTEL_H */
arch/x86/kernel/Makefile +3 -0
@@ -88,6 +88,9 @@ obj-$(CONFIG_PARAVIRT_CLOCK) += pvclock.o obj-$(CONFIG_PCSPKR_PLATFORM) += pcspeaker.o +obj-$(CONFIG_MICROCODE_EARLY) += microcode_core_early.o +obj-$(CONFIG_MICROCODE_INTEL_EARLY) += microcode_intel_early.o +obj-$(CONFIG_MICROCODE_INTEL_LIB) += microcode_intel_lib.o microcode-y := microcode_core.o microcode-$(CONFIG_MICROCODE_INTEL) += microcode_intel.o microcode-$(CONFIG_MICROCODE_AMD) += microcode_amd.o
arch/x86/kernel/microcode_core.c +4 -3
@@ -364,10 +364,7 @@ static struct attribute_group mc_attr_group = {static void microcode_fini_cpu (int cpu) { -struct ucode_cpu_info *uci = ucode_cpu_info + cpu; - microcode_ops->microcode_fini_cpu (cpu); - uci->valid =0 ; }static enum ucode_state microcode_resume_cpu (int cpu)
@@ -383,6 +380,10 @@ static enum ucode_state microcode_resume_cpu(int cpu)static enum ucode_state microcode_init_cpu (int cpu,bool refresh_fw) {enum ucode_state ustate; +struct ucode_cpu_info *uci = ucode_cpu_info + cpu; + +if (uci && uci->valid) +return UCODE_OK ;if (collect_cpu_info (cpu))return UCODE_ERROR ;
arch/x86/kernel/microcode_intel.c +30 -168
253 lines not on this page · raw message
PATCH v5 3/12 x86/common.c: Make have_cpuid_p() a global function
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Remove static declaration in have_cpuid_p() to make it a global function. The function will be called in early loading microcode.
--- arch/x86/include/asm/processor.h | 8 ++++++++ arch/x86/kernel/cpu/common.c | 9 +++------ 2 files changed, 11 insertions(+), 6 deletions(-)
arch/x86/include/asm/processor.h +8 -0
@@ -190,6 +190,14 @@ extern void init_amd_cacheinfo(struct cpuinfo_x86 *c);extern void detect_extended_topology (struct cpuinfo_x86 *c);extern void detect_ht (struct cpuinfo_x86 *c); +#ifdef CONFIG_X86_32 +extern int have_cpuid_p (void ); +#else +static inline int have_cpuid_p (void ) +{ +return 1 ; +} +#endif static inline void native_cpuid (unsigned int *eax,unsigned int *ebx,unsigned int *ecx,unsigned int *edx) {
arch/x86/kernel/cpu/common.c +3 -6
@@ -37,6 +37,8 @@#include <asm/mce.h> #include <asm/msr.h> #include <asm/pat.h> +#include <asm/microcode.h> +#include <asm/microcode_intel.h> #ifdef CONFIG_X86_LOCAL_APIC #include <asm/uv/uv.h>
@@ -213,7 +215,7 @@ static inline int flag_is_changeable_p(u32 flag) }/* Probe for the CPUID instruction */ -static int __cpuinit have_cpuid_p (void ) +int __cpuinit have_cpuid_p (void ) {return flag_is_changeable_p (X86_EFLAGS_ID ); }
@@ -249,11 +251,6 @@ static inline int flag_is_changeable_p(u32 flag) {return 1 ; } -/* Probe for the CPUID instruction */ -static inline int have_cpuid_p (void ) -{ -return 1 ; -}static inline void squash_the_stupid_serial_number (struct cpuinfo_x86 *c) { }
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/common.c: Make have_cpuid_p() a global function
Commit-ID: d288e1cf8e62f3e4034f1f021f047009c4ac0b3c Gitweb: http://git.kernel.org/tip/d288e1cf8e62f3e4034f1f021f047009c4ac0b3c Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:23 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:18:58 -0800
x86/common.c: Make have_cpuid_p() a global function
Remove static declaration in have_cpuid_p() to make it a global function. The function will be called in early loading microcode.
--- arch/x86/include/asm/processor.h | 8 ++++++++ arch/x86/kernel/cpu/common.c | 9 +++------ 2 files changed, 11 insertions(+), 6 deletions(-)
arch/x86/include/asm/processor.h +8 -0
@@ -190,6 +190,14 @@ extern void init_amd_cacheinfo(struct cpuinfo_x86 *c);extern void detect_extended_topology (struct cpuinfo_x86 *c);extern void detect_ht (struct cpuinfo_x86 *c); +#ifdef CONFIG_X86_32 +extern int have_cpuid_p (void ); +#else +static inline int have_cpuid_p (void ) +{ +return 1 ; +} +#endif static inline void native_cpuid (unsigned int *eax,unsigned int *ebx,unsigned int *ecx,unsigned int *edx) {
arch/x86/kernel/cpu/common.c +3 -6
@@ -37,6 +37,8 @@#include <asm/mce.h> #include <asm/msr.h> #include <asm/pat.h> +#include <asm/microcode.h> +#include <asm/microcode_intel.h> #ifdef CONFIG_X86_LOCAL_APIC #include <asm/uv/uv.h>
@@ -213,7 +215,7 @@ static inline int flag_is_changeable_p(u32 flag) }/* Probe for the CPUID instruction */ -static int __cpuinit have_cpuid_p (void ) +int __cpuinit have_cpuid_p (void ) {return flag_is_changeable_p (X86_EFLAGS_ID ); }
@@ -249,11 +251,6 @@ static inline int flag_is_changeable_p(u32 flag) {return 1 ; } -/* Probe for the CPUID instruction */ -static inline int have_cpuid_p (void ) -{ -return 1 ; -}static inline void squash_the_stupid_serial_number (struct cpuinfo_x86 *c) { }
PATCH v5 4/12 x86/common.c: load ucode in 64 bit or show loading ucode info in 32 bit on AP
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
In 64 bit, load ucode on AP in cpu_init().
In 32 bit, show ucode loading info on AP in cpu_init(). Microcode has been loaded earlier before paging. Now it is safe to show the loading microcode info on this AP.
--- arch/x86/kernel/cpu/common.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/x86/kernel/cpu/common.c +8 -0
@@ -1220,6 +1220,12 @@ void __cpuinit cpu_init(void)int cpu;int i; +/* +* Load microcode on this cpu if a valid microcode is available. +* This is early microcode loading procedure. +*/ +load_ucode_ap (); + cpu =stack_smp_processor_id (); t = &per_cpu (init_tss, cpu); oist = &per_cpu (orig_ist, cpu);
@@ -1311,6 +1317,8 @@ void __cpuinit cpu_init(void)struct tss_struct *t = &per_cpu (init_tss, cpu);struct thread_struct *thread = &curr->thread; +show_ucode_info_early (); +if (cpumask_test_and_set_cpu (cpu, cpu_initialized_mask)) {printk (KERN_WARNING "CPU#%d already initialized!\n" , cpu);for (;;)
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/common.c: load ucode in 64 bit or show loading ucode info in 32 bit on AP
Commit-ID: e6ebf5deaaaa33b661f0db86380c232b162bd68c Gitweb: http://git.kernel.org/tip/e6ebf5deaaaa33b661f0db86380c232b162bd68c Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:24 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:06 -0800
x86/common.c: load ucode in 64 bit or show loading ucode info in 32 bit on AP
In 64 bit, load ucode on AP in cpu_init().
In 32 bit, show ucode loading info on AP in cpu_init(). Microcode has been loaded earlier before paging. Now it is safe to show the loading microcode info on this AP.
--- arch/x86/kernel/cpu/common.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/x86/kernel/cpu/common.c +8 -0
@@ -1220,6 +1220,12 @@ void __cpuinit cpu_init(void)int cpu;int i; +/* +* Load microcode on this cpu if a valid microcode is available. +* This is early microcode loading procedure. +*/ +load_ucode_ap (); + cpu =stack_smp_processor_id (); t = &per_cpu (init_tss, cpu); oist = &per_cpu (orig_ist, cpu);
@@ -1311,6 +1317,8 @@ void __cpuinit cpu_init(void)struct tss_struct *t = &per_cpu (init_tss, cpu);struct thread_struct *thread = &curr->thread; +show_ucode_info_early (); +if (cpumask_test_and_set_cpu (cpu, cpu_initialized_mask)) {printk (KERN_WARNING "CPU#%d already initialized!\n" , cpu);for (;;)
PATCH v5 5/12 x86/microcode_core_early.c: Define interfaces for early loading ucode
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Define interfaces load_ucode_bsp() and load_ucode_ap() to load ucode on BSP and AP in early boot time. These are generic interfaces. Internally they call vendor specific implementations.
--- arch/x86/include/asm/microcode.h | 14 +++++++ arch/x86/kernel/microcode_core_early.c | 76 ++++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+) create mode 100644 arch/x86/kernel/microcode_core_early.c
arch/x86/include/asm/microcode.h +14 -0
@@ -57,4 +57,18 @@ static inline struct microcode_ops * __init init_amd_microcode(void) static inline void __exit exit_amd_microcode(void) {}#endif +#ifdef CONFIG_MICROCODE_EARLY +#define MAX_UCODE_COUNT 128 +extern void __init load_ucode_bsp (void ); +extern __init void load_ucode_ap (void ); +extern int __init save_microcode_in_initrd (void ); +#else +static inline void __init load_ucode_bsp (void ) {} +static inline __init void load_ucode_ap (void ) {} +static inline int __init save_microcode_in_initrd (void ) +{ +return 0 ; +} +#endif +#endif /* _ASM_X86_MICROCODE_H */
arch/x86/kernel/microcode_core_early.c new file +76 -0
76 lines not on this page · raw message
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/microcode_core_early.c: Define interfaces for early loading ucode
Commit-ID: a8ebf6d1d6971b90a20f5bd0465e6d520377e33b Gitweb: http://git.kernel.org/tip/a8ebf6d1d6971b90a20f5bd0465e6d520377e33b Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:25 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:12 -0800
x86/microcode_core_early.c: Define interfaces for early loading ucode
Define interfaces load_ucode_bsp() and load_ucode_ap() to load ucode on BSP and AP in early boot time. These are generic interfaces. Internally they call vendor specific implementations.
--- arch/x86/include/asm/microcode.h | 14 +++++++ arch/x86/kernel/microcode_core_early.c | 76 ++++++++++++++++++++++++++++++++++ 2 files changed, 90 insertions(+)
arch/x86/include/asm/microcode.h +14 -0
@@ -57,4 +57,18 @@ static inline struct microcode_ops * __init init_amd_microcode(void) static inline void __exit exit_amd_microcode(void) {}#endif +#ifdef CONFIG_MICROCODE_EARLY +#define MAX_UCODE_COUNT 128 +extern void __init load_ucode_bsp (void ); +extern __init void load_ucode_ap (void ); +extern int __init save_microcode_in_initrd (void ); +#else +static inline void __init load_ucode_bsp (void ) {} +static inline __init void load_ucode_ap (void ) {} +static inline int __init save_microcode_in_initrd (void ) +{ +return 0 ; +} +#endif +#endif /* _ASM_X86_MICROCODE_H */
arch/x86/kernel/microcode_core_early.c new file +76 -0
76 lines not on this page · raw message
PATCH v5 6/12 x86/microcode_intel_lib.c: Early update ucode on Intel's CPU
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Define interfaces microcode_sanity_check() and get_matching_microcode(). They are called both in early boot time and in microcode Intel driver.
--- arch/x86/kernel/microcode_intel_lib.c | 174 ++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) create mode 100644 arch/x86/kernel/microcode_intel_lib.c
arch/x86/kernel/microcode_intel_lib.c new file +174 -0
@@ -0,0 +1,174 @@ +/* +* Intel CPU Microcode Update Driver for Linux +* +* Copyright (C) 2012 Fenghua Yu <[email protected]> +* H Peter Anvin" <[email protected]> +* +* This driver allows to upgrade microcode on Intel processors +* belonging to IA-32 family - PentiumPro, Pentium II, +* Pentium III, Xeon, Pentium 4, etc. +* +* Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture +* Software Developer's Manual +* Order Number 253668 or free download from: +* +* http://developer.intel.com/Assets/PDF/manual/253668.pdf +* +* For more information, go to http://www.urbanmyth.org/microcode +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version +* 2 of the License, or (at your option) any later version. +* +*/ +#include <linux/firmware.h> +#include <linux/uaccess.h> +#include <linux/kernel.h> +#include <linux/module.h> + +#include <asm/microcode_intel.h> +#include <asm/processor.h> +#include <asm/msr.h> + +static inline int +update_match_cpu (unsigned int csig,unsigned int cpf, +unsigned int sig,unsigned int pf) +{ +return (!sigmatch (sig, csig, pf, cpf)) ?0 :1 ; +} + +int +update_match_revision (struct microcode_header_intel *mc_header,int rev) +{ +return (mc_header->rev <= rev) ?0 :1 ; +} + +int microcode_sanity_check (void *mc,int print_err) +{ +unsigned long total_size, data_size, ext_table_size; +struct microcode_header_intel *mc_header = mc; +struct extended_sigtable *ext_header =NULL ; +int sum, orig_sum, ext_sigcount =0 , i; +struct extended_signature *ext_sig; + + total_size =get_totalsize (mc_header); + data_size =get_datasize (mc_header); + +if (data_size +MC_HEADER_SIZE > total_size) { +if (print_err) +pr_err ("error! Bad data size in microcode data file\n" ); +return -EINVAL ; + } + +if (mc_header->ldrver !=1 || mc_header->hdrver !=1 ) { +if (print_err) +pr_err ("error! Unknown microcode update format\n" ); +return -EINVAL ; + } + ext_table_size = total_size - (MC_HEADER_SIZE + data_size); +if (ext_table_size) { +if ((ext_table_size <EXT_HEADER_SIZE ) + || ((ext_table_size -EXT_HEADER_SIZE ) %EXT_SIGNATURE_SIZE )) { +if (print_err) +pr_err ("error! Small exttable size in microcode data file\n" ); +return -EINVAL ; + } + ext_header = mc +MC_HEADER_SIZE + data_size; +if (ext_table_size !=exttable_size (ext_header)) { +if (print_err) +pr_err ("error! Bad exttable size in microcode data file\n" ); +return -EFAULT ; + } + ext_sigcount = ext_header->count; + } + +/* check extended table checksum */ +if (ext_table_size) { +int ext_table_sum =0 ; +int *ext_tablep = (int *)ext_header; + + i = ext_table_size /DWSIZE ; +while (i--) + ext_table_sum += ext_tablep[i]; +if (ext_table_sum) { +if (print_err) +pr_warn ("aborting, bad extended signature table checksum\n" ); +return -EINVAL ; + } + } + +/* calculate the checksum */ + orig_sum =0 ; + i = (MC_HEADER_SIZE + data_size) /DWSIZE ; +while (i--) + orig_sum += ((int *)mc)[i]; +if (orig_sum) { +if (print_err) +pr_err ("aborting, bad checksum\n" ); +return -EINVAL ; + } +if (!ext_table_size) +return 0 ; +/* check extended signature checksum */ +for (i =0 ; i < ext_sigcount; i++) { + ext_sig = (void *)ext_header +EXT_HEADER_SIZE + +EXT_SIGNATURE_SIZE * i; + sum = orig_sum + - (mc_header->sig + mc_header->pf + mc_header->cksum) + + (ext_sig->sig + ext_sig->pf + ext_sig->cksum); +if (sum) { +if (print_err) +pr_err ("aborting, bad checksum\n" ); +return -EINVAL ; + } + } +return 0 ; +} +EXPORT_SYMBOL_GPL (microcode_sanity_check); + +/* +* return 0 - no update found +* return 1 - found update +*/ +int get_matching_sig (unsigned int csig,int cpf,void *mc,int rev) +{ +struct microcode_header_intel *mc_header = mc; +struct extended_sigtable *ext_header; +unsigned long total_size =get_totalsize (mc_header); +int ext_sigcount, i; +struct extended_signature *ext_sig; + +if (update_match_cpu (csig, cpf, mc_header->sig, mc_header->pf)) +return 1 ; + +/* Look for ext. headers: */ +if (total_size <=get_datasize (mc_header) +MC_HEADER_SIZE ) +return 0 ; + + ext_header = mc +get_datasize (mc_header) +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (i =0 ; i < ext_sigcount; i++) { +if (update_match_cpu (csig, cpf, ext_sig->sig, ext_sig->pf)) +return 1 ; + ext_sig++; + } +return 0 ; +} + +/* +* return 0 - no update found +* return 1 - found update +*/ +int get_matching_microcode (unsigned int csig,int cpf,void *mc,int rev) +{ +struct microcode_header_intel *mc_header = mc; + +if (!update_match_revision (mc_header, rev)) +return 0 ; + +return get_matching_sig (csig, cpf, mc, rev); +} +EXPORT_SYMBOL_GPL (get_matching_microcode);
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/microcode_intel_lib.c: Early update ucode on Intel's CPU
Commit-ID: e666dfa273db1b12711eaec91facac5fec2ec851 Gitweb: http://git.kernel.org/tip/e666dfa273db1b12711eaec91facac5fec2ec851 Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:26 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:14 -0800
x86/microcode_intel_lib.c: Early update ucode on Intel's CPU
Define interfaces microcode_sanity_check() and get_matching_microcode(). They are called both in early boot time and in microcode Intel driver.
--- arch/x86/kernel/microcode_intel_lib.c | 174 ++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+)
arch/x86/kernel/microcode_intel_lib.c new file +174 -0
@@ -0,0 +1,174 @@ +/* +* Intel CPU Microcode Update Driver for Linux +* +* Copyright (C) 2012 Fenghua Yu <[email protected]> +* H Peter Anvin" <[email protected]> +* +* This driver allows to upgrade microcode on Intel processors +* belonging to IA-32 family - PentiumPro, Pentium II, +* Pentium III, Xeon, Pentium 4, etc. +* +* Reference: Section 8.11 of Volume 3a, IA-32 Intel? Architecture +* Software Developer's Manual +* Order Number 253668 or free download from: +* +* http://developer.intel.com/Assets/PDF/manual/253668.pdf +* +* For more information, go to http://www.urbanmyth.org/microcode +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version +* 2 of the License, or (at your option) any later version. +* +*/ +#include <linux/firmware.h> +#include <linux/uaccess.h> +#include <linux/kernel.h> +#include <linux/module.h> + +#include <asm/microcode_intel.h> +#include <asm/processor.h> +#include <asm/msr.h> + +static inline int +update_match_cpu (unsigned int csig,unsigned int cpf, +unsigned int sig,unsigned int pf) +{ +return (!sigmatch (sig, csig, pf, cpf)) ?0 :1 ; +} + +int +update_match_revision (struct microcode_header_intel *mc_header,int rev) +{ +return (mc_header->rev <= rev) ?0 :1 ; +} + +int microcode_sanity_check (void *mc,int print_err) +{ +unsigned long total_size, data_size, ext_table_size; +struct microcode_header_intel *mc_header = mc; +struct extended_sigtable *ext_header =NULL ; +int sum, orig_sum, ext_sigcount =0 , i; +struct extended_signature *ext_sig; + + total_size =get_totalsize (mc_header); + data_size =get_datasize (mc_header); + +if (data_size +MC_HEADER_SIZE > total_size) { +if (print_err) +pr_err ("error! Bad data size in microcode data file\n" ); +return -EINVAL ; + } + +if (mc_header->ldrver !=1 || mc_header->hdrver !=1 ) { +if (print_err) +pr_err ("error! Unknown microcode update format\n" ); +return -EINVAL ; + } + ext_table_size = total_size - (MC_HEADER_SIZE + data_size); +if (ext_table_size) { +if ((ext_table_size <EXT_HEADER_SIZE ) + || ((ext_table_size -EXT_HEADER_SIZE ) %EXT_SIGNATURE_SIZE )) { +if (print_err) +pr_err ("error! Small exttable size in microcode data file\n" ); +return -EINVAL ; + } + ext_header = mc +MC_HEADER_SIZE + data_size; +if (ext_table_size !=exttable_size (ext_header)) { +if (print_err) +pr_err ("error! Bad exttable size in microcode data file\n" ); +return -EFAULT ; + } + ext_sigcount = ext_header->count; + } + +/* check extended table checksum */ +if (ext_table_size) { +int ext_table_sum =0 ; +int *ext_tablep = (int *)ext_header; + + i = ext_table_size /DWSIZE ; +while (i--) + ext_table_sum += ext_tablep[i]; +if (ext_table_sum) { +if (print_err) +pr_warn ("aborting, bad extended signature table checksum\n" ); +return -EINVAL ; + } + } + +/* calculate the checksum */ + orig_sum =0 ; + i = (MC_HEADER_SIZE + data_size) /DWSIZE ; +while (i--) + orig_sum += ((int *)mc)[i]; +if (orig_sum) { +if (print_err) +pr_err ("aborting, bad checksum\n" ); +return -EINVAL ; + } +if (!ext_table_size) +return 0 ; +/* check extended signature checksum */ +for (i =0 ; i < ext_sigcount; i++) { + ext_sig = (void *)ext_header +EXT_HEADER_SIZE + +EXT_SIGNATURE_SIZE * i; + sum = orig_sum + - (mc_header->sig + mc_header->pf + mc_header->cksum) + + (ext_sig->sig + ext_sig->pf + ext_sig->cksum); +if (sum) { +if (print_err) +pr_err ("aborting, bad checksum\n" ); +return -EINVAL ; + } + } +return 0 ; +} +EXPORT_SYMBOL_GPL (microcode_sanity_check); + +/* +* return 0 - no update found +* return 1 - found update +*/ +int get_matching_sig (unsigned int csig,int cpf,void *mc,int rev) +{ +struct microcode_header_intel *mc_header = mc; +struct extended_sigtable *ext_header; +unsigned long total_size =get_totalsize (mc_header); +int ext_sigcount, i; +struct extended_signature *ext_sig; + +if (update_match_cpu (csig, cpf, mc_header->sig, mc_header->pf)) +return 1 ; + +/* Look for ext. headers: */ +if (total_size <=get_datasize (mc_header) +MC_HEADER_SIZE ) +return 0 ; + + ext_header = mc +get_datasize (mc_header) +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (i =0 ; i < ext_sigcount; i++) { +if (update_match_cpu (csig, cpf, ext_sig->sig, ext_sig->pf)) +return 1 ; + ext_sig++; + } +return 0 ; +} + +/* +* return 0 - no update found +* return 1 - found update +*/ +int get_matching_microcode (unsigned int csig,int cpf,void *mc,int rev) +{ +struct microcode_header_intel *mc_header = mc; + +if (!update_match_revision (mc_header, rev)) +return 0 ; + +return get_matching_sig (csig, cpf, mc, rev); +} +EXPORT_SYMBOL_GPL (get_matching_microcode);
PATCH v5 7/12 x86/tlbflush.h: Define __native_flush_tlb_global_irq_disabled()
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
This function is called in __native_flush_tlb_global() and after apply_microcode_early().
--- arch/x86/include/asm/tlbflush.h | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-)
arch/x86/include/asm/tlbflush.h +12 -6
@@ -20,10 +20,20 @@ static inline void __native_flush_tlb(void)native_write_cr3 (native_read_cr3 ()); } +static inline void __native_flush_tlb_global_irq_disabled (void ) +{ +unsigned long cr4; + + cr4 =native_read_cr4 (); +/* clear PGE */ +native_write_cr4 (cr4 & ~X86_CR4_PGE ); +/* write old PGE again and flush TLBs */ +native_write_cr4 (cr4); +} +static inline void __native_flush_tlb_global (void ) {unsigned long flags; -unsigned long cr4;/* * Read-modify-write to CR4 - protect it from preemption and
@@ -32,11 +42,7 @@ static inline void __native_flush_tlb_global(void)*/ raw_local_irq_save (flags); - cr4 =native_read_cr4 (); -/* clear PGE */ -native_write_cr4 (cr4 & ~X86_CR4_PGE ); -/* write old PGE again and flush TLBs */ -native_write_cr4 (cr4); +__native_flush_tlb_global_irq_disabled ();raw_local_irq_restore (flags); }
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/tlbflush.h: Define __native_flush_tlb_global_irq_disabled()
Commit-ID: 086fc8f8037bf16f55f82c66b26a8b834f7349ec Gitweb: http://git.kernel.org/tip/086fc8f8037bf16f55f82c66b26a8b834f7349ec Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:27 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:16 -0800
x86/tlbflush.h: Define __native_flush_tlb_global_irq_disabled()
This function is called in __native_flush_tlb_global() and after apply_microcode_early().
--- arch/x86/include/asm/tlbflush.h | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-)
arch/x86/include/asm/tlbflush.h +12 -6
@@ -20,10 +20,20 @@ static inline void __native_flush_tlb(void)native_write_cr3 (native_read_cr3 ()); } +static inline void __native_flush_tlb_global_irq_disabled (void ) +{ +unsigned long cr4; + + cr4 =native_read_cr4 (); +/* clear PGE */ +native_write_cr4 (cr4 & ~X86_CR4_PGE ); +/* write old PGE again and flush TLBs */ +native_write_cr4 (cr4); +} +static inline void __native_flush_tlb_global (void ) {unsigned long flags; -unsigned long cr4;/* * Read-modify-write to CR4 - protect it from preemption and
@@ -32,11 +42,7 @@ static inline void __native_flush_tlb_global(void)*/ raw_local_irq_save (flags); - cr4 =native_read_cr4 (); -/* clear PGE */ -native_write_cr4 (cr4 & ~X86_CR4_PGE ); -/* write old PGE again and flush TLBs */ -native_write_cr4 (cr4); +__native_flush_tlb_global_irq_disabled ();raw_local_irq_restore (flags); }
PATCH v5 8/12 x86/microcode_intel_early.c: Early update ucode on Intel's CPU
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Implementation of early update ucode on Intel's CPU.
load_ucode_intel_bsp() scans ucode in initrd image file which is a cpio format ucode followed by ordinary initrd image file. The binary ucode file is stored in kernel/x86/microcode/GenuineIntel.bin in the cpio data. All ucode patches with the same model as BSP are saved in memory. A matching ucode patch is updated on BSP.
load_ucode_intel_ap() reads saved ucoded patches and updates ucode on AP.
--- arch/x86/kernel/microcode_intel_early.c | 796 ++++++++++++++++++++++++++++++++ 1 file changed, 796 insertions(+) create mode 100644 arch/x86/kernel/microcode_intel_early.c
arch/x86/kernel/microcode_intel_early.c new file +796 -0
@@ -0,0 +1,796 @@ +/* +* Intel CPU microcode early update for Linux +* +* Copyright (C) 2012 Fenghua Yu <[email protected]> +* H Peter Anvin" <[email protected]> +* +* This allows to early upgrade microcode on Intel processors +* belonging to IA-32 family - PentiumPro, Pentium II, +* Pentium III, Xeon, Pentium 4, etc. +* +* Reference: Section 9.11 of Volume 3, IA-32 Intel Architecture +* Software Developer's Manual. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version +* 2 of the License, or (at your option) any later version. +*/ +#include <linux/module.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/earlycpio.h> +#include <linux/initrd.h> +#include <linux/cpu.h> +#include <asm/msr.h> +#include <asm/microcode_intel.h> +#include <asm/processor.h> +#include <asm/tlbflush.h> +#include <asm/setup.h> + +unsigned long mc_saved_in_initrd[MAX_UCODE_COUNT ]; +struct mc_saved_data { +unsigned int mc_saved_count; +struct microcode_intel **mc_saved; +} mc_saved_data; + +static enum ucode_state __cpuinit +generic_load_microcode_early (struct microcode_intel **mc_saved_p, +unsigned int mc_saved_count, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *ucode_ptr, *new_mc =NULL ; +int new_rev = uci->cpu_sig.rev; +enum ucode_state state =UCODE_OK ; +unsigned int mc_size; +struct microcode_header_intel *mc_header; +unsigned int csig = uci->cpu_sig.sig; +unsigned int cpf = uci->cpu_sig.pf; +int i; + +for (i =0 ; i < mc_saved_count; i++) { + ucode_ptr = mc_saved_p[i]; + + mc_header = (struct microcode_header_intel *)ucode_ptr; + mc_size =get_totalsize (mc_header); +if (get_matching_microcode (csig, cpf, ucode_ptr, new_rev)) { + new_rev = mc_header->rev; + new_mc = ucode_ptr; + } + } + +if (!new_mc) { + state =UCODE_NFOUND ; + goto out; + } + + uci->mc = (struct microcode_intel *)new_mc; +out: +return state; +} + +static void __cpuinit +microcode_pointer (struct microcode_intel **mc_saved, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start,int mc_saved_count) +{ +int i; + +for (i =0 ; i < mc_saved_count; i++) + mc_saved[i] = (struct microcode_intel *) + (mc_saved_in_initrd[i] + initrd_start); +} + +#ifdef CONFIG_X86_32 +static void __cpuinit +microcode_phys (struct microcode_intel **mc_saved_tmp, +struct mc_saved_data *mc_saved_data) +{ +int i; +struct microcode_intel ***mc_saved; + + mc_saved = (struct microcode_intel ***) +__pa_symbol (&mc_saved_data->mc_saved); +for (i =0 ; i < mc_saved_data->mc_saved_count; i++) { +struct microcode_intel *p; + + p = *(struct microcode_intel **) +__pa (mc_saved_data->mc_saved + i); + mc_saved_tmp[i] = (struct microcode_intel *)__pa (p); + } +} +#endif + +static enum ucode_state __cpuinit +load_microcode (struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int count = mc_saved_data->mc_saved_count; + +if (!mc_saved_data->mc_saved) { +microcode_pointer (mc_saved_tmp, mc_saved_in_initrd, + initrd_start, count); + +return generic_load_microcode_early (mc_saved_tmp, count, uci); + }else { +#ifdef CONFIG_X86_32 +microcode_phys (mc_saved_tmp, mc_saved_data); +return generic_load_microcode_early (mc_saved_tmp, count, uci); +#else +return generic_load_microcode_early (mc_saved_data->mc_saved, + count, uci); +#endif + } +} + +static u8 get_x86_family (unsigned long sig) +{ +u8 x86; + + x86 = (sig >>8 ) &0xf ; + +if (x86 ==0xf ) + x86 += (sig >>20 ) &0xff ; + +return x86; +} + +static u8 get_x86_model (unsigned long sig) +{ +u8 x86, x86_model; + + x86 =get_x86_family (sig); + x86_model = (sig >>4 ) &0xf ; + +if (x86 ==0x6 || x86 ==0xf ) + x86_model += ((sig >>16 ) &0xf ) <<4 ; + +return x86_model; +} + +/* +* Given CPU signature and a microcode patch, this function finds if the +* microcode patch has matching family and model with the CPU. +*/ +static enum ucode_state +matching_model_microcode (struct microcode_header_intel *mc_header, +unsigned long sig) +{ +u8 x86, x86_model; +u8 x86_ucode, x86_model_ucode; +struct extended_sigtable *ext_header; +unsigned long total_size =get_totalsize (mc_header); +unsigned long data_size =get_datasize (mc_header); +int ext_sigcount, i; +struct extended_signature *ext_sig; + + x86 =get_x86_family (sig); + x86_model =get_x86_model (sig); + + x86_ucode =get_x86_family (mc_header->sig); + x86_model_ucode =get_x86_model (mc_header->sig); + +if (x86 == x86_ucode && x86_model == x86_model_ucode) +return UCODE_OK ; + +/* Look for ext. headers: */ +if (total_size <= data_size +MC_HEADER_SIZE ) +return UCODE_NFOUND ; + + ext_header = (struct extended_sigtable *) + mc_header + data_size +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (i =0 ; i < ext_sigcount; i++) { + x86_ucode =get_x86_family (ext_sig->sig); + x86_model_ucode =get_x86_model (ext_sig->sig); + +if (x86 == x86_ucode && x86_model == x86_model_ucode) +return UCODE_OK ; + + ext_sig++; + } + +return UCODE_NFOUND ; +} + +static int +save_microcode (struct mc_saved_data *mc_saved_data, +struct microcode_intel **mc_saved_src, +unsigned int mc_saved_count) +{ +int i, j; +struct microcode_intel **mc_saved_p; +int ret; + +if (!mc_saved_count) +return -EINVAL ; + +/* +* Copy new microcode data. +*/ + mc_saved_p =kmalloc (mc_saved_count*sizeof (struct microcode_intel *), +GFP_KERNEL ); +if (!mc_saved_p) +return -ENOMEM ; + +for (i =0 ; i < mc_saved_count; i++) { +struct microcode_intel *mc = mc_saved_src[i]; +struct microcode_header_intel *mc_header = &mc->hdr; +unsigned long mc_size =get_totalsize (mc_header); + mc_saved_p[i] =kmalloc (mc_size,GFP_KERNEL ); +if (!mc_saved_p[i]) { + ret = -ENOMEM ; + goto err; + } +if (!mc_saved_src[i]) { + ret = -EINVAL ; + goto err; + } +memcpy (mc_saved_p[i], mc, mc_size); + } + +/* +* Point to newly saved microcode. +*/ + mc_saved_data->mc_saved = mc_saved_p; + mc_saved_data->mc_saved_count = mc_saved_count; + +return 0 ; + +err: +for (j =0 ; j <= i; j++) +kfree (mc_saved_p[j]); +kfree (mc_saved_p); + +return ret; +} + +/* +* A microcode patch in ucode_ptr is saved into mc_saved +* - if it has matching signature and newer revision compared to an existing +* patch mc_saved. +* - or if it is a newly discovered microcode patch. +* +* The microcode patch should have matching model with CPU. +*/ +static void _save_mc (struct microcode_intel **mc_saved,u8 *ucode_ptr, +unsigned int *mc_saved_count_p) +{ +int i; +int found =0 ; +unsigned int mc_saved_count = *mc_saved_count_p; +struct microcode_header_intel *mc_header; + + mc_header = (struct microcode_header_intel *)ucode_ptr; +for (i =0 ; i < mc_saved_count; i++) { +unsigned int sig, pf; +unsigned int new_rev; +struct microcode_header_intel *mc_saved_header = + (struct microcode_header_intel *)mc_saved[i]; + sig = mc_saved_header->sig; + pf = mc_saved_header->pf; + new_rev = mc_header->rev; + +if (get_matching_sig (sig, pf, ucode_ptr, new_rev)) { + found =1 ; +if (update_match_revision (mc_header, new_rev)) { +/* +* Found an older ucode saved before. +* Replace the older one with this newer +* one. +*/ + mc_saved[i] = + (struct microcode_intel *)ucode_ptr; +break ; + } + } + } +if (i >= mc_saved_count && !found) +/* +* This ucode is first time discovered in ucode file. +* Save it to memory. +*/ + mc_saved[mc_saved_count++] = + (struct microcode_intel *)ucode_ptr; + + *mc_saved_count_p = mc_saved_count; +} + +/* +* Get microcode matching with BSP's model. Only CPUs with the same model as +* BSP can stay in the platform. +*/ +static enum ucode_state __init +get_matching_model_microcode (int cpu,unsigned long start, +void *data,size_t size, +struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +struct ucode_cpu_info *uci) +{ +u8 *ucode_ptr = data; +unsigned int leftover = size; +enum ucode_state state =UCODE_OK ; +unsigned int mc_size; +struct microcode_header_intel *mc_header; +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int mc_saved_count = mc_saved_data->mc_saved_count; +int i; + +while (leftover) { + mc_header = (struct microcode_header_intel *)ucode_ptr; + + mc_size =get_totalsize (mc_header); +if (!mc_size || mc_size > leftover || +microcode_sanity_check (ucode_ptr,0 ) <0 ) +break ; + + leftover -= mc_size; + +/* +* Since APs with same family and model as the BSP may boot in +* the platform, we need to find and save microcode patches +* with the same family and model as the BSP. +*/ +if (matching_model_microcode (mc_header, uci->cpu_sig.sig) != +UCODE_OK ) { + ucode_ptr += mc_size; +continue ; + } + +_save_mc (mc_saved_tmp, ucode_ptr, &mc_saved_count); + + ucode_ptr += mc_size; + } + +if (leftover) { + state =UCODE_ERROR ; + goto out; + } + +if (mc_saved_count ==0 ) { + state =UCODE_NFOUND ; + goto out; + } + +for (i =0 ; i < mc_saved_count; i++) + mc_saved_in_initrd[i] = (unsigned long )mc_saved_tmp[i] - start; + + mc_saved_data->mc_saved_count = mc_saved_count; +out: +return state; +} + +#define native_rdmsr (msr, val1, val2) \ +do { \ + u64 __val = native_read_msr((msr)); \ + (void)((val1) = (u32)__val); \ + (void)((val2) = (u32)(__val >> 32)); \ +} while (0) + +#define native_wrmsr (msr, low, high) \ + native_write_msr(msr, low, high); + +static int __cpuinit collect_cpu_info_early (struct ucode_cpu_info *uci) +{ +unsigned int val[2 ]; +u8 x86, x86_model; +struct cpu_signature csig; +unsigned int eax, ebx, ecx, edx; + + csig.sig =0 ; + csig.pf =0 ; + csig.rev =0 ; + +memset (uci,0 ,sizeof (*uci)); + + eax =0x00000001 ; + ecx =0 ; +native_cpuid (&eax, &ebx, &ecx, &edx); + csig.sig = eax; + + x86 =get_x86_family (csig.sig); + x86_model =get_x86_model (csig.sig); + +if ((x86_model >=5 ) || (x86 >6 )) { +/* get processor flags from MSR 0x17 */ +native_rdmsr (MSR_IA32_PLATFORM_ID , val[0 ], val[1 ]); + csig.pf =1 << ((val[1 ] >>18 ) &7 ); + } +native_wrmsr (MSR_IA32_UCODE_REV ,0 ,0 ); + +/* As documented in the SDM: Do a CPUID 1 here */ +sync_core (); + +/* get the current revision from MSR 0x8B */ +native_rdmsr (MSR_IA32_UCODE_REV , val[0 ], val[1 ]); + + csig.rev = val[1 ]; + + uci->cpu_sig = csig; + uci->valid =1 ; + +return 0 ; +} + +#ifdef DEBUG +static void __ref show_saved_mc (void ) +{ +int i, j; +unsigned int sig, pf, rev, total_size, data_size, date; +struct ucode_cpu_info uci; + +if (mc_saved_data.mc_saved_count ==0 ) { +pr_debug ("no micorcode data saved.\n" ); +return ; + } +pr_debug ("Total microcode saved: %d\n" , mc_saved_data.mc_saved_count); + +collect_cpu_info_early (&uci); + + sig = uci.cpu_sig.sig; + pf = uci.cpu_sig.pf; + rev = uci.cpu_sig.rev; +pr_debug ("CPU%d: sig=0x%x, pf=0x%x, rev=0x%x\n" , +smp_processor_id (), sig, pf, rev); + +for (i =0 ; i < mc_saved_data.mc_saved_count; i++) { +struct microcode_header_intel *mc_saved_header; +struct extended_sigtable *ext_header; +int ext_sigcount; +struct extended_signature *ext_sig; + + mc_saved_header = (struct microcode_header_intel *) + mc_saved_data.mc_saved[i]; + sig = mc_saved_header->sig; + pf = mc_saved_header->pf; + rev = mc_saved_header->rev; + total_size =get_totalsize (mc_saved_header); + data_size =get_datasize (mc_saved_header); + date = mc_saved_header->date; + +pr_debug ("mc_saved[%d]: sig=0x%x, pf=0x%x, rev=0x%x, toal size=0x%x, date = %04x-%02x-%02x\n" , + i, sig, pf, rev, total_size, + date &0xffff , + date >>24 , + (date >>16 ) &0xff ); + +/* Look for ext. headers: */ +if (total_size <= data_size +MC_HEADER_SIZE ) +continue ; + + ext_header = (struct extended_sigtable *) + mc_saved_header + data_size +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (j =0 ; j < ext_sigcount; j++) { + sig = ext_sig->sig; + pf = ext_sig->pf; + +pr_debug ("\tExtended[%d]: sig=0x%x, pf=0x%x\n" , + j, sig, pf); + + ext_sig++; + } + + } +} +#else +static inline void show_saved_mc (void ) +{ +} +#endif + +#if defined(CONFIG_MICROCODE_INTEL_EARLY ) && defined(CONFIG_HOTPLUG_CPU ) +/* +* Save this mc into mc_saved_data. So it will be loaded early when a CPU is +* hot added or resumes. +* +* Please make sure this mc should be a valid microcode patch before calling +* this function. +*/ +int save_mc_for_early (u8 *mc) +{ +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int mc_saved_count_init; +unsigned int mc_saved_count; +struct microcode_intel **mc_saved; +int ret =0 ; +int i; + +/* +* Hold hotplug lock so mc_saved_data is not accessed by a CPU in +* hotplug. +*/ +cpu_hotplug_driver_lock (); + + mc_saved_count_init = mc_saved_data.mc_saved_count; + mc_saved_count = mc_saved_data.mc_saved_count; + mc_saved = mc_saved_data.mc_saved; + +if (mc_saved && mc_saved_count) +memcpy (mc_saved_tmp, mc_saved, + mc_saved_count *sizeof (struct mirocode_intel *)); +/* +* Save the microcode patch mc in mc_save_tmp structure if it's a newer +* version. +*/ + +_save_mc (mc_saved_tmp, mc, &mc_saved_count); + +/* +* Save the mc_save_tmp in global mc_saved_data. +*/ + ret =save_microcode (&mc_saved_data, mc_saved_tmp, mc_saved_count); +if (ret) { +pr_err ("Can not save microcode patch.\n" ); + goto out; + } + +show_saved_mc (); + +/* +* Free old saved microcod data. +*/ +if (mc_saved) { +for (i =0 ; i < mc_saved_count_init; i++) +kfree (mc_saved[i]); +kfree (mc_saved); + } + +out: +cpu_hotplug_driver_unlock (); + +return ret; +} +EXPORT_SYMBOL_GPL (save_mc_for_early); +#endif + +static __initdata char ucode_name[] ="kernel/x86/microcode/GenuineIntel.bin" ; +static __init enum ucode_state +scan_microcode (unsigned long start,unsigned long end, +struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +struct ucode_cpu_info *uci) +{ +unsigned int size = end - start +1 ; +struct cpio_data cd; +long offset =0 ; +#ifdef CONFIG_X86_32 +char *p = (char *)__pa_symbol (ucode_name); +#else +char *p = ucode_name; +#endif + + cd.data =NULL ; + cd.size =0 ; + + cd =find_cpio_data (p, (void *)start, size, &offset); +if (!cd.data) +return UCODE_ERROR ; + + +return get_matching_model_microcode (0 , start, cd.data, cd.size, + mc_saved_data, mc_saved_in_initrd, + uci); +} + +/* +* Print ucode update info. +*/ +static void __cpuinit +print_ucode_info (struct ucode_cpu_info *uci,unsigned int date) +{ +int cpu =smp_processor_id (); + +pr_info ("CPU%d microcode updated early to revision 0x%x, date = %04x-%02x-%02x\n" , + cpu, + uci->cpu_sig.rev, + date &0xffff , + date >>24 , + (date >>16 ) &0xff ); +} + +#ifdef CONFIG_X86_32 + +static int delay_ucode_info; +static int current_mc_date; + +/* +* Print early updated ucode info after printk works. This is delayed info dump. +*/ +void __cpuinit show_ucode_info_early (void ) +{ +struct ucode_cpu_info uci; + +if (delay_ucode_info) { +collect_cpu_info_early (&uci); +print_ucode_info (&uci, current_mc_date); + delay_ucode_info =0 ; + } +} + +/* +* At this point, we can not call printk() yet. Keep microcode patch number in +* mc_saved_data.mc_saved and delay printing microcode info in +* show_ucode_info_early() until printk() works. +*/ +static void __cpuinit print_ucode (struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; +int *delay_ucode_info_p; +int *current_mc_date_p; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return ; + + delay_ucode_info_p = (int *)__pa_symbol (&delay_ucode_info); + current_mc_date_p = (int *)__pa_symbol (¤t_mc_date); + + *delay_ucode_info_p =1 ; + *current_mc_date_p = mc_intel->hdr.date; +} +#else + +/* +* Flush global tlb. We only do this in x86_64 where paging has been enabled +* already and PGE should be enabled as well. +*/ +static inline void __cpuinit flush_tlb_early (void ) +{ +__native_flush_tlb_global_irq_disabled (); +} + +static inline void __cpuinit print_ucode (struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return ; + +print_ucode_info (uci, mc_intel->hdr.date); +} +#endif + +static int apply_microcode_early (struct mc_saved_data *mc_saved_data, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; +unsigned int val[2 ]; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return 0 ; + +/* write microcode via MSR 0x79 */ +native_wrmsr (MSR_IA32_UCODE_WRITE , + (unsigned long ) mc_intel->bits, + (unsigned long ) mc_intel->bits >>16 >>16 ); +native_wrmsr (MSR_IA32_UCODE_REV ,0 ,0 ); + +/* As documented in the SDM: Do a CPUID 1 here */ +sync_core (); + +/* get the current revision from MSR 0x8B */ +native_rdmsr (MSR_IA32_UCODE_REV , val[0 ], val[1 ]); +if (val[1 ] != mc_intel->hdr.rev) +return -1 ; + +#ifdef CONFIG_X86_64 +/* Flush global tlb. This is precaution. */ +flush_tlb_early (); +#endif + uci->cpu_sig.rev = val[1 ]; + +print_ucode (uci); + +return 0 ; +} + +/* +* This function converts microcode patch offsets previously stored in +* mc_saved_in_initrd to pointers and stores the pointers in mc_saved_data. +*/ +int __init save_microcode_in_initrd (void ) +{ +unsigned int count = mc_saved_data.mc_saved_count; +struct microcode_intel *mc_saved[MAX_UCODE_COUNT ]; +int ret =0 ; + +if (count ==0 ) +return ret; + +microcode_pointer (mc_saved, mc_saved_in_initrd, initrd_start, count); + ret =save_microcode (&mc_saved_data, mc_saved, count); +if (ret) +pr_err ("Can not save microcod patches from initrd" ); + +show_saved_mc (); + +return ret; +} + +static void __init +_load_ucode_intel_bsp (struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start_early, +unsigned long initrd_end_early, +struct ucode_cpu_info *uci) +{ +collect_cpu_info_early (uci); +scan_microcode (initrd_start_early, initrd_end_early, mc_saved_data, + mc_saved_in_initrd, uci); +load_microcode (mc_saved_data, mc_saved_in_initrd, + initrd_start_early, uci); +apply_microcode_early (mc_saved_data, uci); +} + +void __init +load_ucode_intel_bsp (void ) +{ +u64 ramdisk_image, ramdisk_size; +unsigned long initrd_start_early, initrd_end_early; +struct ucode_cpu_info uci; +#ifdef CONFIG_X86_32 +struct boot_params *boot_params_p; + + boot_params_p = (struct boot_params *)__pa_symbol (&boot_params); + ramdisk_image = boot_params_p->hdr.ramdisk_image; + ramdisk_size = boot_params_p->hdr.ramdisk_size; + initrd_start_early = ramdisk_image; + initrd_end_early = initrd_start_early + ramdisk_size; + +_load_ucode_intel_bsp ( + (struct mc_saved_data *)__pa_symbol (&mc_saved_data), + (unsigned long *)__pa_symbol (&mc_saved_in_initrd), + initrd_start_early, initrd_end_early, &uci); +#else + ramdisk_image = boot_params.hdr.ramdisk_image; + ramdisk_size = boot_params.hdr.ramdisk_size; + initrd_start_early = ramdisk_image +PAGE_OFFSET ; + initrd_end_early = initrd_start_early + ramdisk_size; + +_load_ucode_intel_bsp (&mc_saved_data, mc_saved_in_initrd, + initrd_start_early, initrd_end_early, &uci); +#endif +} + +void __cpuinit load_ucode_intel_ap (void ) +{ +struct mc_saved_data *mc_saved_data_p; +struct ucode_cpu_info uci; +unsigned long *mc_saved_in_initrd_p; +unsigned long initrd_start_addr; +#ifdef CONFIG_X86_32 +unsigned long *initrd_start_p; + + mc_saved_in_initrd_p = + (unsigned long *)__pa_symbol (mc_saved_in_initrd); + mc_saved_data_p = (struct mc_saved_data *)__pa_symbol (&mc_saved_data); + initrd_start_p = (unsigned long *)__pa_symbol (&initrd_start); + initrd_start_addr = (unsigned long )__pa_symbol (*initrd_start_p); +#else + mc_saved_data_p = &mc_saved_data; + mc_saved_in_initrd_p = mc_saved_in_initrd; + initrd_start_addr = initrd_start; +#endif + +/* +* If there is no valid ucode previously saved in memory, no need to +* update ucode on this AP. +*/ +if (mc_saved_data_p->mc_saved_count ==0 ) +return ; + +collect_cpu_info_early (&uci); +load_microcode (mc_saved_data_p, mc_saved_in_initrd_p, + initrd_start_addr, &uci); +apply_microcode_early (mc_saved_data_p, &uci); +}
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/microcode_intel_early.c: Early update ucode on Intel's CPU
Commit-ID: ec400ddeff200b068ddc6c70f7321f49ecf32ed5 Gitweb: http://git.kernel.org/tip/ec400ddeff200b068ddc6c70f7321f49ecf32ed5 Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:28 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:18 -0800
x86/microcode_intel_early.c: Early update ucode on Intel's CPU
Implementation of early update ucode on Intel's CPU.
load_ucode_intel_bsp() scans ucode in initrd image file which is a cpio format ucode followed by ordinary initrd image file. The binary ucode file is stored in kernel/x86/microcode/GenuineIntel.bin in the cpio data. All ucode patches with the same model as BSP are saved in memory. A matching ucode patch is updated on BSP.
load_ucode_intel_ap() reads saved ucoded patches and updates ucode on AP.
--- arch/x86/kernel/microcode_intel_early.c | 796 ++++++++++++++++++++++++++++++++ 1 file changed, 796 insertions(+)
arch/x86/kernel/microcode_intel_early.c new file +796 -0
@@ -0,0 +1,796 @@ +/* +* Intel CPU microcode early update for Linux +* +* Copyright (C) 2012 Fenghua Yu <[email protected]> +* H Peter Anvin" <[email protected]> +* +* This allows to early upgrade microcode on Intel processors +* belonging to IA-32 family - PentiumPro, Pentium II, +* Pentium III, Xeon, Pentium 4, etc. +* +* Reference: Section 9.11 of Volume 3, IA-32 Intel Architecture +* Software Developer's Manual. +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version +* 2 of the License, or (at your option) any later version. +*/ +#include <linux/module.h> +#include <linux/mm.h> +#include <linux/slab.h> +#include <linux/earlycpio.h> +#include <linux/initrd.h> +#include <linux/cpu.h> +#include <asm/msr.h> +#include <asm/microcode_intel.h> +#include <asm/processor.h> +#include <asm/tlbflush.h> +#include <asm/setup.h> + +unsigned long mc_saved_in_initrd[MAX_UCODE_COUNT ]; +struct mc_saved_data { +unsigned int mc_saved_count; +struct microcode_intel **mc_saved; +} mc_saved_data; + +static enum ucode_state __cpuinit +generic_load_microcode_early (struct microcode_intel **mc_saved_p, +unsigned int mc_saved_count, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *ucode_ptr, *new_mc =NULL ; +int new_rev = uci->cpu_sig.rev; +enum ucode_state state =UCODE_OK ; +unsigned int mc_size; +struct microcode_header_intel *mc_header; +unsigned int csig = uci->cpu_sig.sig; +unsigned int cpf = uci->cpu_sig.pf; +int i; + +for (i =0 ; i < mc_saved_count; i++) { + ucode_ptr = mc_saved_p[i]; + + mc_header = (struct microcode_header_intel *)ucode_ptr; + mc_size =get_totalsize (mc_header); +if (get_matching_microcode (csig, cpf, ucode_ptr, new_rev)) { + new_rev = mc_header->rev; + new_mc = ucode_ptr; + } + } + +if (!new_mc) { + state =UCODE_NFOUND ; + goto out; + } + + uci->mc = (struct microcode_intel *)new_mc; +out: +return state; +} + +static void __cpuinit +microcode_pointer (struct microcode_intel **mc_saved, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start,int mc_saved_count) +{ +int i; + +for (i =0 ; i < mc_saved_count; i++) + mc_saved[i] = (struct microcode_intel *) + (mc_saved_in_initrd[i] + initrd_start); +} + +#ifdef CONFIG_X86_32 +static void __cpuinit +microcode_phys (struct microcode_intel **mc_saved_tmp, +struct mc_saved_data *mc_saved_data) +{ +int i; +struct microcode_intel ***mc_saved; + + mc_saved = (struct microcode_intel ***) +__pa_symbol (&mc_saved_data->mc_saved); +for (i =0 ; i < mc_saved_data->mc_saved_count; i++) { +struct microcode_intel *p; + + p = *(struct microcode_intel **) +__pa (mc_saved_data->mc_saved + i); + mc_saved_tmp[i] = (struct microcode_intel *)__pa (p); + } +} +#endif + +static enum ucode_state __cpuinit +load_microcode (struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int count = mc_saved_data->mc_saved_count; + +if (!mc_saved_data->mc_saved) { +microcode_pointer (mc_saved_tmp, mc_saved_in_initrd, + initrd_start, count); + +return generic_load_microcode_early (mc_saved_tmp, count, uci); + }else { +#ifdef CONFIG_X86_32 +microcode_phys (mc_saved_tmp, mc_saved_data); +return generic_load_microcode_early (mc_saved_tmp, count, uci); +#else +return generic_load_microcode_early (mc_saved_data->mc_saved, + count, uci); +#endif + } +} + +static u8 get_x86_family (unsigned long sig) +{ +u8 x86; + + x86 = (sig >>8 ) &0xf ; + +if (x86 ==0xf ) + x86 += (sig >>20 ) &0xff ; + +return x86; +} + +static u8 get_x86_model (unsigned long sig) +{ +u8 x86, x86_model; + + x86 =get_x86_family (sig); + x86_model = (sig >>4 ) &0xf ; + +if (x86 ==0x6 || x86 ==0xf ) + x86_model += ((sig >>16 ) &0xf ) <<4 ; + +return x86_model; +} + +/* +* Given CPU signature and a microcode patch, this function finds if the +* microcode patch has matching family and model with the CPU. +*/ +static enum ucode_state +matching_model_microcode (struct microcode_header_intel *mc_header, +unsigned long sig) +{ +u8 x86, x86_model; +u8 x86_ucode, x86_model_ucode; +struct extended_sigtable *ext_header; +unsigned long total_size =get_totalsize (mc_header); +unsigned long data_size =get_datasize (mc_header); +int ext_sigcount, i; +struct extended_signature *ext_sig; + + x86 =get_x86_family (sig); + x86_model =get_x86_model (sig); + + x86_ucode =get_x86_family (mc_header->sig); + x86_model_ucode =get_x86_model (mc_header->sig); + +if (x86 == x86_ucode && x86_model == x86_model_ucode) +return UCODE_OK ; + +/* Look for ext. headers: */ +if (total_size <= data_size +MC_HEADER_SIZE ) +return UCODE_NFOUND ; + + ext_header = (struct extended_sigtable *) + mc_header + data_size +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (i =0 ; i < ext_sigcount; i++) { + x86_ucode =get_x86_family (ext_sig->sig); + x86_model_ucode =get_x86_model (ext_sig->sig); + +if (x86 == x86_ucode && x86_model == x86_model_ucode) +return UCODE_OK ; + + ext_sig++; + } + +return UCODE_NFOUND ; +} + +static int +save_microcode (struct mc_saved_data *mc_saved_data, +struct microcode_intel **mc_saved_src, +unsigned int mc_saved_count) +{ +int i, j; +struct microcode_intel **mc_saved_p; +int ret; + +if (!mc_saved_count) +return -EINVAL ; + +/* +* Copy new microcode data. +*/ + mc_saved_p =kmalloc (mc_saved_count*sizeof (struct microcode_intel *), +GFP_KERNEL ); +if (!mc_saved_p) +return -ENOMEM ; + +for (i =0 ; i < mc_saved_count; i++) { +struct microcode_intel *mc = mc_saved_src[i]; +struct microcode_header_intel *mc_header = &mc->hdr; +unsigned long mc_size =get_totalsize (mc_header); + mc_saved_p[i] =kmalloc (mc_size,GFP_KERNEL ); +if (!mc_saved_p[i]) { + ret = -ENOMEM ; + goto err; + } +if (!mc_saved_src[i]) { + ret = -EINVAL ; + goto err; + } +memcpy (mc_saved_p[i], mc, mc_size); + } + +/* +* Point to newly saved microcode. +*/ + mc_saved_data->mc_saved = mc_saved_p; + mc_saved_data->mc_saved_count = mc_saved_count; + +return 0 ; + +err: +for (j =0 ; j <= i; j++) +kfree (mc_saved_p[j]); +kfree (mc_saved_p); + +return ret; +} + +/* +* A microcode patch in ucode_ptr is saved into mc_saved +* - if it has matching signature and newer revision compared to an existing +* patch mc_saved. +* - or if it is a newly discovered microcode patch. +* +* The microcode patch should have matching model with CPU. +*/ +static void _save_mc (struct microcode_intel **mc_saved,u8 *ucode_ptr, +unsigned int *mc_saved_count_p) +{ +int i; +int found =0 ; +unsigned int mc_saved_count = *mc_saved_count_p; +struct microcode_header_intel *mc_header; + + mc_header = (struct microcode_header_intel *)ucode_ptr; +for (i =0 ; i < mc_saved_count; i++) { +unsigned int sig, pf; +unsigned int new_rev; +struct microcode_header_intel *mc_saved_header = + (struct microcode_header_intel *)mc_saved[i]; + sig = mc_saved_header->sig; + pf = mc_saved_header->pf; + new_rev = mc_header->rev; + +if (get_matching_sig (sig, pf, ucode_ptr, new_rev)) { + found =1 ; +if (update_match_revision (mc_header, new_rev)) { +/* +* Found an older ucode saved before. +* Replace the older one with this newer +* one. +*/ + mc_saved[i] = + (struct microcode_intel *)ucode_ptr; +break ; + } + } + } +if (i >= mc_saved_count && !found) +/* +* This ucode is first time discovered in ucode file. +* Save it to memory. +*/ + mc_saved[mc_saved_count++] = + (struct microcode_intel *)ucode_ptr; + + *mc_saved_count_p = mc_saved_count; +} + +/* +* Get microcode matching with BSP's model. Only CPUs with the same model as +* BSP can stay in the platform. +*/ +static enum ucode_state __init +get_matching_model_microcode (int cpu,unsigned long start, +void *data,size_t size, +struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +struct ucode_cpu_info *uci) +{ +u8 *ucode_ptr = data; +unsigned int leftover = size; +enum ucode_state state =UCODE_OK ; +unsigned int mc_size; +struct microcode_header_intel *mc_header; +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int mc_saved_count = mc_saved_data->mc_saved_count; +int i; + +while (leftover) { + mc_header = (struct microcode_header_intel *)ucode_ptr; + + mc_size =get_totalsize (mc_header); +if (!mc_size || mc_size > leftover || +microcode_sanity_check (ucode_ptr,0 ) <0 ) +break ; + + leftover -= mc_size; + +/* +* Since APs with same family and model as the BSP may boot in +* the platform, we need to find and save microcode patches +* with the same family and model as the BSP. +*/ +if (matching_model_microcode (mc_header, uci->cpu_sig.sig) != +UCODE_OK ) { + ucode_ptr += mc_size; +continue ; + } + +_save_mc (mc_saved_tmp, ucode_ptr, &mc_saved_count); + + ucode_ptr += mc_size; + } + +if (leftover) { + state =UCODE_ERROR ; + goto out; + } + +if (mc_saved_count ==0 ) { + state =UCODE_NFOUND ; + goto out; + } + +for (i =0 ; i < mc_saved_count; i++) + mc_saved_in_initrd[i] = (unsigned long )mc_saved_tmp[i] - start; + + mc_saved_data->mc_saved_count = mc_saved_count; +out: +return state; +} + +#define native_rdmsr (msr, val1, val2) \ +do { \ + u64 __val = native_read_msr((msr)); \ + (void)((val1) = (u32)__val); \ + (void)((val2) = (u32)(__val >> 32)); \ +} while (0) + +#define native_wrmsr (msr, low, high) \ + native_write_msr(msr, low, high); + +static int __cpuinit collect_cpu_info_early (struct ucode_cpu_info *uci) +{ +unsigned int val[2 ]; +u8 x86, x86_model; +struct cpu_signature csig; +unsigned int eax, ebx, ecx, edx; + + csig.sig =0 ; + csig.pf =0 ; + csig.rev =0 ; + +memset (uci,0 ,sizeof (*uci)); + + eax =0x00000001 ; + ecx =0 ; +native_cpuid (&eax, &ebx, &ecx, &edx); + csig.sig = eax; + + x86 =get_x86_family (csig.sig); + x86_model =get_x86_model (csig.sig); + +if ((x86_model >=5 ) || (x86 >6 )) { +/* get processor flags from MSR 0x17 */ +native_rdmsr (MSR_IA32_PLATFORM_ID , val[0 ], val[1 ]); + csig.pf =1 << ((val[1 ] >>18 ) &7 ); + } +native_wrmsr (MSR_IA32_UCODE_REV ,0 ,0 ); + +/* As documented in the SDM: Do a CPUID 1 here */ +sync_core (); + +/* get the current revision from MSR 0x8B */ +native_rdmsr (MSR_IA32_UCODE_REV , val[0 ], val[1 ]); + + csig.rev = val[1 ]; + + uci->cpu_sig = csig; + uci->valid =1 ; + +return 0 ; +} + +#ifdef DEBUG +static void __ref show_saved_mc (void ) +{ +int i, j; +unsigned int sig, pf, rev, total_size, data_size, date; +struct ucode_cpu_info uci; + +if (mc_saved_data.mc_saved_count ==0 ) { +pr_debug ("no micorcode data saved.\n" ); +return ; + } +pr_debug ("Total microcode saved: %d\n" , mc_saved_data.mc_saved_count); + +collect_cpu_info_early (&uci); + + sig = uci.cpu_sig.sig; + pf = uci.cpu_sig.pf; + rev = uci.cpu_sig.rev; +pr_debug ("CPU%d: sig=0x%x, pf=0x%x, rev=0x%x\n" , +smp_processor_id (), sig, pf, rev); + +for (i =0 ; i < mc_saved_data.mc_saved_count; i++) { +struct microcode_header_intel *mc_saved_header; +struct extended_sigtable *ext_header; +int ext_sigcount; +struct extended_signature *ext_sig; + + mc_saved_header = (struct microcode_header_intel *) + mc_saved_data.mc_saved[i]; + sig = mc_saved_header->sig; + pf = mc_saved_header->pf; + rev = mc_saved_header->rev; + total_size =get_totalsize (mc_saved_header); + data_size =get_datasize (mc_saved_header); + date = mc_saved_header->date; + +pr_debug ("mc_saved[%d]: sig=0x%x, pf=0x%x, rev=0x%x, toal size=0x%x, date = %04x-%02x-%02x\n" , + i, sig, pf, rev, total_size, + date &0xffff , + date >>24 , + (date >>16 ) &0xff ); + +/* Look for ext. headers: */ +if (total_size <= data_size +MC_HEADER_SIZE ) +continue ; + + ext_header = (struct extended_sigtable *) + mc_saved_header + data_size +MC_HEADER_SIZE ; + ext_sigcount = ext_header->count; + ext_sig = (void *)ext_header +EXT_HEADER_SIZE ; + +for (j =0 ; j < ext_sigcount; j++) { + sig = ext_sig->sig; + pf = ext_sig->pf; + +pr_debug ("\tExtended[%d]: sig=0x%x, pf=0x%x\n" , + j, sig, pf); + + ext_sig++; + } + + } +} +#else +static inline void show_saved_mc (void ) +{ +} +#endif + +#if defined(CONFIG_MICROCODE_INTEL_EARLY ) && defined(CONFIG_HOTPLUG_CPU ) +/* +* Save this mc into mc_saved_data. So it will be loaded early when a CPU is +* hot added or resumes. +* +* Please make sure this mc should be a valid microcode patch before calling +* this function. +*/ +int save_mc_for_early (u8 *mc) +{ +struct microcode_intel *mc_saved_tmp[MAX_UCODE_COUNT ]; +unsigned int mc_saved_count_init; +unsigned int mc_saved_count; +struct microcode_intel **mc_saved; +int ret =0 ; +int i; + +/* +* Hold hotplug lock so mc_saved_data is not accessed by a CPU in +* hotplug. +*/ +cpu_hotplug_driver_lock (); + + mc_saved_count_init = mc_saved_data.mc_saved_count; + mc_saved_count = mc_saved_data.mc_saved_count; + mc_saved = mc_saved_data.mc_saved; + +if (mc_saved && mc_saved_count) +memcpy (mc_saved_tmp, mc_saved, + mc_saved_count *sizeof (struct mirocode_intel *)); +/* +* Save the microcode patch mc in mc_save_tmp structure if it's a newer +* version. +*/ + +_save_mc (mc_saved_tmp, mc, &mc_saved_count); + +/* +* Save the mc_save_tmp in global mc_saved_data. +*/ + ret =save_microcode (&mc_saved_data, mc_saved_tmp, mc_saved_count); +if (ret) { +pr_err ("Can not save microcode patch.\n" ); + goto out; + } + +show_saved_mc (); + +/* +* Free old saved microcod data. +*/ +if (mc_saved) { +for (i =0 ; i < mc_saved_count_init; i++) +kfree (mc_saved[i]); +kfree (mc_saved); + } + +out: +cpu_hotplug_driver_unlock (); + +return ret; +} +EXPORT_SYMBOL_GPL (save_mc_for_early); +#endif + +static __initdata char ucode_name[] ="kernel/x86/microcode/GenuineIntel.bin" ; +static __init enum ucode_state +scan_microcode (unsigned long start,unsigned long end, +struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +struct ucode_cpu_info *uci) +{ +unsigned int size = end - start +1 ; +struct cpio_data cd; +long offset =0 ; +#ifdef CONFIG_X86_32 +char *p = (char *)__pa_symbol (ucode_name); +#else +char *p = ucode_name; +#endif + + cd.data =NULL ; + cd.size =0 ; + + cd =find_cpio_data (p, (void *)start, size, &offset); +if (!cd.data) +return UCODE_ERROR ; + + +return get_matching_model_microcode (0 , start, cd.data, cd.size, + mc_saved_data, mc_saved_in_initrd, + uci); +} + +/* +* Print ucode update info. +*/ +static void __cpuinit +print_ucode_info (struct ucode_cpu_info *uci,unsigned int date) +{ +int cpu =smp_processor_id (); + +pr_info ("CPU%d microcode updated early to revision 0x%x, date = %04x-%02x-%02x\n" , + cpu, + uci->cpu_sig.rev, + date &0xffff , + date >>24 , + (date >>16 ) &0xff ); +} + +#ifdef CONFIG_X86_32 + +static int delay_ucode_info; +static int current_mc_date; + +/* +* Print early updated ucode info after printk works. This is delayed info dump. +*/ +void __cpuinit show_ucode_info_early (void ) +{ +struct ucode_cpu_info uci; + +if (delay_ucode_info) { +collect_cpu_info_early (&uci); +print_ucode_info (&uci, current_mc_date); + delay_ucode_info =0 ; + } +} + +/* +* At this point, we can not call printk() yet. Keep microcode patch number in +* mc_saved_data.mc_saved and delay printing microcode info in +* show_ucode_info_early() until printk() works. +*/ +static void __cpuinit print_ucode (struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; +int *delay_ucode_info_p; +int *current_mc_date_p; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return ; + + delay_ucode_info_p = (int *)__pa_symbol (&delay_ucode_info); + current_mc_date_p = (int *)__pa_symbol (¤t_mc_date); + + *delay_ucode_info_p =1 ; + *current_mc_date_p = mc_intel->hdr.date; +} +#else + +/* +* Flush global tlb. We only do this in x86_64 where paging has been enabled +* already and PGE should be enabled as well. +*/ +static inline void __cpuinit flush_tlb_early (void ) +{ +__native_flush_tlb_global_irq_disabled (); +} + +static inline void __cpuinit print_ucode (struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return ; + +print_ucode_info (uci, mc_intel->hdr.date); +} +#endif + +static int apply_microcode_early (struct mc_saved_data *mc_saved_data, +struct ucode_cpu_info *uci) +{ +struct microcode_intel *mc_intel; +unsigned int val[2 ]; + + mc_intel = uci->mc; +if (mc_intel ==NULL ) +return 0 ; + +/* write microcode via MSR 0x79 */ +native_wrmsr (MSR_IA32_UCODE_WRITE , + (unsigned long ) mc_intel->bits, + (unsigned long ) mc_intel->bits >>16 >>16 ); +native_wrmsr (MSR_IA32_UCODE_REV ,0 ,0 ); + +/* As documented in the SDM: Do a CPUID 1 here */ +sync_core (); + +/* get the current revision from MSR 0x8B */ +native_rdmsr (MSR_IA32_UCODE_REV , val[0 ], val[1 ]); +if (val[1 ] != mc_intel->hdr.rev) +return -1 ; + +#ifdef CONFIG_X86_64 +/* Flush global tlb. This is precaution. */ +flush_tlb_early (); +#endif + uci->cpu_sig.rev = val[1 ]; + +print_ucode (uci); + +return 0 ; +} + +/* +* This function converts microcode patch offsets previously stored in +* mc_saved_in_initrd to pointers and stores the pointers in mc_saved_data. +*/ +int __init save_microcode_in_initrd (void ) +{ +unsigned int count = mc_saved_data.mc_saved_count; +struct microcode_intel *mc_saved[MAX_UCODE_COUNT ]; +int ret =0 ; + +if (count ==0 ) +return ret; + +microcode_pointer (mc_saved, mc_saved_in_initrd, initrd_start, count); + ret =save_microcode (&mc_saved_data, mc_saved, count); +if (ret) +pr_err ("Can not save microcod patches from initrd" ); + +show_saved_mc (); + +return ret; +} + +static void __init +_load_ucode_intel_bsp (struct mc_saved_data *mc_saved_data, +unsigned long *mc_saved_in_initrd, +unsigned long initrd_start_early, +unsigned long initrd_end_early, +struct ucode_cpu_info *uci) +{ +collect_cpu_info_early (uci); +scan_microcode (initrd_start_early, initrd_end_early, mc_saved_data, + mc_saved_in_initrd, uci); +load_microcode (mc_saved_data, mc_saved_in_initrd, + initrd_start_early, uci); +apply_microcode_early (mc_saved_data, uci); +} + +void __init +load_ucode_intel_bsp (void ) +{ +u64 ramdisk_image, ramdisk_size; +unsigned long initrd_start_early, initrd_end_early; +struct ucode_cpu_info uci; +#ifdef CONFIG_X86_32 +struct boot_params *boot_params_p; + + boot_params_p = (struct boot_params *)__pa_symbol (&boot_params); + ramdisk_image = boot_params_p->hdr.ramdisk_image; + ramdisk_size = boot_params_p->hdr.ramdisk_size; + initrd_start_early = ramdisk_image; + initrd_end_early = initrd_start_early + ramdisk_size; + +_load_ucode_intel_bsp ( + (struct mc_saved_data *)__pa_symbol (&mc_saved_data), + (unsigned long *)__pa_symbol (&mc_saved_in_initrd), + initrd_start_early, initrd_end_early, &uci); +#else + ramdisk_image = boot_params.hdr.ramdisk_image; + ramdisk_size = boot_params.hdr.ramdisk_size; + initrd_start_early = ramdisk_image +PAGE_OFFSET ; + initrd_end_early = initrd_start_early + ramdisk_size; + +_load_ucode_intel_bsp (&mc_saved_data, mc_saved_in_initrd, + initrd_start_early, initrd_end_early, &uci); +#endif +} + +void __cpuinit load_ucode_intel_ap (void ) +{ +struct mc_saved_data *mc_saved_data_p; +struct ucode_cpu_info uci; +unsigned long *mc_saved_in_initrd_p; +unsigned long initrd_start_addr; +#ifdef CONFIG_X86_32 +unsigned long *initrd_start_p; + + mc_saved_in_initrd_p = + (unsigned long *)__pa_symbol (mc_saved_in_initrd); + mc_saved_data_p = (struct mc_saved_data *)__pa_symbol (&mc_saved_data); + initrd_start_p = (unsigned long *)__pa_symbol (&initrd_start); + initrd_start_addr = (unsigned long )__pa_symbol (*initrd_start_p); +#else + mc_saved_data_p = &mc_saved_data; + mc_saved_in_initrd_p = mc_saved_in_initrd; + initrd_start_addr = initrd_start; +#endif + +/* +* If there is no valid ucode previously saved in memory, no need to +* update ucode on this AP. +*/ +if (mc_saved_data_p->mc_saved_count ==0 ) +return ; + +collect_cpu_info_early (&uci); +load_microcode (mc_saved_data_p, mc_saved_in_initrd_p, + initrd_start_addr, &uci); +apply_microcode_early (mc_saved_data_p, &uci); +}
PATCH v5 9/12 x86/head_32.S: Early update ucode in 32-bit
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
This updates ucode in 32-bit kernel on BSP and AP. At this point, there is no paging and no virtual address yet.
--- arch/x86/kernel/head_32.S | 11 +++++++++++ 1 file changed, 11 insertions(+)
arch/x86/kernel/head_32.S +11 -0
@@ -144,6 +144,11 @@ ENTRY(startup_32) movl %eax, pa(olpc_ofw_pgd) #endif +#ifdef CONFIG_MICROCODE_EARLY + /* Early load ucode on BSP. */ + call load_ucode_bsp +#endif + /* * Initialize page tables. This creates a PDE and a set of page * tables, which are located immediately beyond __brk_base. The variable
@@ -299,6 +304,12 @@ ENTRY(startup_32_smp) movl %eax,%ss leal -__PAGE_OFFSET(%ecx),%esp +#ifdef CONFIG_MICROCODE_EARLY + /* Early load ucode on AP. */ + call load_ucode_ap +#endif + + default_entry: /* * New page tables may be in 4Mbyte page mode and may
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/head_32.S: Early update ucode in 32-bit
Commit-ID: 63b553c68db5a8d4febcd1010b194333d2b02e1c Gitweb: http://git.kernel.org/tip/63b553c68db5a8d4febcd1010b194333d2b02e1c Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:29 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:19:20 -0800
x86/head_32.S: Early update ucode in 32-bit
This updates ucode in 32-bit kernel on BSP and AP. At this point, there is no paging and no virtual address yet.
--- arch/x86/kernel/head_32.S | 11 +++++++++++ 1 file changed, 11 insertions(+)
arch/x86/kernel/head_32.S +11 -0
@@ -144,6 +144,11 @@ ENTRY(startup_32) movl %eax, pa(olpc_ofw_pgd) #endif +#ifdef CONFIG_MICROCODE_EARLY + /* Early load ucode on BSP. */ + call load_ucode_bsp +#endif + /* * Initialize page tables. This creates a PDE and a set of page * tables, which are located immediately beyond __brk_base. The variable
@@ -299,6 +304,12 @@ ENTRY(startup_32_smp) movl %eax,%ss leal -__PAGE_OFFSET(%ecx),%esp +#ifdef CONFIG_MICROCODE_EARLY + /* Early load ucode on AP. */ + call load_ucode_ap +#endif + + default_entry: /* * New page tables may be in 4Mbyte page mode and may
PATCH v5 10/12 x86/head64.c: Early update ucode in 64-bit
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
This updates ucode on BSP in 64-bit mode. Paging and virtual address are working now.
--- arch/x86/kernel/head64.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/kernel/head64.c +6 -0
@@ -26,6 +26,7 @@#include <asm/kdebug.h> #include <asm/e820.h> #include <asm/bios_ebda.h> +#include <asm/microcode.h> /* * Manage page tables very early on.
@@ -181,6 +182,11 @@ void __init x86_64_start_kernel(char * real_mode_data)copy_bootdata (__va (real_mode_data)); +/* +* Load microcode early on BSP. +*/ +load_ucode_bsp (); +if (console_loglevel ==10 )early_printk ("Kernel alive\n" );
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/head64.c: Early update ucode in 64-bit
Commit-ID: feddc9de8bf69415da6f96eca0219186b70d145a Gitweb: http://git.kernel.org/tip/feddc9de8bf69415da6f96eca0219186b70d145a Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:30 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:20:24 -0800
x86/head64.c: Early update ucode in 64-bit
This updates ucode on BSP in 64-bit mode. Paging and virtual address are working now.
--- arch/x86/kernel/head64.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/kernel/head64.c +6 -0
@@ -26,6 +26,7 @@#include <asm/e820.h> #include <asm/bios_ebda.h> #include <asm/bootparam_utils.h> +#include <asm/microcode.h> /* * Manage page tables very early on.
@@ -170,6 +171,11 @@ void __init x86_64_start_kernel(char * real_mode_data)copy_bootdata (__va (real_mode_data)); +/* +* Load microcode early on BSP. +*/ +load_ucode_bsp (); +if (console_loglevel ==10 )early_printk ("Kernel alive\n" );
PATCH v5 11/12 x86/mm/init.c: Copy ucode from initrd image to kernel memory
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
Before initrd image is freed, copy valid ucode patches from initrd image to kernel memory. The saved ucode will be used to update AP in resume or hotplug.
--- arch/x86/mm/init.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
arch/x86/mm/init.c +10 -0
@@ -16,6 +16,7 @@#include <asm/tlb.h> #include <asm/proto.h> #include <asm/dma.h> /* for MAX_DMA_PFN */ +#include <asm/microcode.h> #include "mm_internal.h"
@@ -555,6 +556,15 @@ void free_initmem(void)#ifdef CONFIG_BLK_DEV_INITRD void __init free_initrd_mem (unsigned long start,unsigned long end) { +#ifdef CONFIG_MICROCODE_EARLY +/* +* Remember, initrd memory may contain microcode or other useful things. +* Before we lose initrd mem, we need to find a place to hold them +* now that normal virtual memory is enabled. +*/ +save_microcode_in_initrd (); +#endif +/* * end could be not aligned, and We can not align that, * decompresser could be confused by aligned initrd_end
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/mm/init.c: Copy ucode from initrd image to kernel memory
Commit-ID: cd745be89e1580e8a1b47454a39f97f9c5c4b1e0 Gitweb: http://git.kernel.org/tip/cd745be89e1580e8a1b47454a39f97f9c5c4b1e0 Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:31 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:20:26 -0800
x86/mm/init.c: Copy ucode from initrd image to kernel memory
Before initrd image is freed, copy valid ucode patches from initrd image to kernel memory. The saved ucode will be used to update AP in resume or hotplug.
--- arch/x86/mm/init.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
arch/x86/mm/init.c +10 -0
@@ -16,6 +16,7 @@#include <asm/tlb.h> #include <asm/proto.h> #include <asm/dma.h> /* for MAX_DMA_PFN */ +#include <asm/microcode.h> #include "mm_internal.h"
@@ -534,6 +535,15 @@ void free_initmem(void)#ifdef CONFIG_BLK_DEV_INITRD void __init free_initrd_mem (unsigned long start,unsigned long end) { +#ifdef CONFIG_MICROCODE_EARLY +/* +* Remember, initrd memory may contain microcode or other useful things. +* Before we lose initrd mem, we need to find a place to hold them +* now that normal virtual memory is enabled. +*/ +save_microcode_in_initrd (); +#endif +/* * end could be not aligned, and We can not align that, * decompresser could be confused by aligned initrd_end
PATCH v5 12/12 x86/Kconfig: Configurations to enable/disable the feature
In reply to Fenghua YuFrom: Fenghua Yu <[email protected]>
MICROCODE_INTEL_LIB, MICROCODE_INTEL_EARLY, and MICROCODE_EARLY are three new configurations to enable or disable the feature.
--- arch/x86/Kconfig | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
arch/x86/Kconfig +18 -0
@@ -1030,6 +1030,24 @@ config MICROCODE_OLD_INTERFACE def_bool y depends on MICROCODE +config MICROCODE_INTEL_LIB + def_bool y + depends on MICROCODE_INTEL + +config MICROCODE_INTEL_EARLY + bool "Early load microcode" + depends on MICROCODE_INTEL && BLK_DEV_INITRD + default y + help + This option provides functionality to read additional microcode data + at the beginning of initrd image. The data tells kernel to load + microcode to CPU's as early as possible. No functional change if no + microcode data is glued to the initrd, therefore it's safe to say Y. + +config MICROCODE_EARLY + def_bool y + depends on MICROCODE_INTEL_EARLY + config X86_MSR tristate "/dev/cpu/*/msr - Model-specific register support" ---help---
Signature · 1 line
1.8.0.1
[tip:x86/microcode] x86/Kconfig: Make early microcode loading a configuration feature
Commit-ID: da76f64e7eb28b718501d15c1b79af560b7ca4ea Gitweb: http://git.kernel.org/tip/da76f64e7eb28b718501d15c1b79af560b7ca4ea Author: Fenghua Yu <[email protected]> AuthorDate: Thu, 20 Dec 2012 23:44:32 -0800 Committer: H. Peter Anvin <[email protected]> CommitDate: Thu, 31 Jan 2013 13:20:42 -0800
x86/Kconfig: Make early microcode loading a configuration feature
MICROCODE_INTEL_LIB, MICROCODE_INTEL_EARLY, and MICROCODE_EARLY are three new configurations to enable or disable the feature.
--- arch/x86/Kconfig | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+)
arch/x86/Kconfig +18 -0
@@ -1029,6 +1029,24 @@ config MICROCODE_OLD_INTERFACE def_bool y depends on MICROCODE +config MICROCODE_INTEL_LIB + def_bool y + depends on MICROCODE_INTEL + +config MICROCODE_INTEL_EARLY + bool "Early load microcode" + depends on MICROCODE_INTEL && BLK_DEV_INITRD + default y + help + This option provides functionality to read additional microcode data + at the beginning of initrd image. The data tells kernel to load + microcode to CPU's as early as possible. No functional change if no + microcode data is glued to the initrd, therefore it's safe to say Y. + +config MICROCODE_EARLY + def_bool y + depends on MICROCODE_INTEL_EARLY + config X86_MSR tristate "/dev/cpu/*/msr - Model-specific register support" ---help---
Quoted 16 lines · Fenghua Yu
From: Fenghua Yu <[email protected]>
The problem in current microcode loading method is that we load a microcode way, way too late; ideally we should load it before turning paging on. This may only be practical on 32 bits since we can't get to 64-bit mode without paging on, but we should still do it as early as at all possible.
Similarly, we should load the microcode update as early as possible during AP bringup and when processors are brought back online after hotplug or S3/S4.
In order to do that, the microcode patch needs to be permanently present in kernel memory. Each individual patch is fairly small, so that is OK, but the entire blob with support for each CPU is too big. Since only CPU's with same model can be in the same platform, we store microcode with the same model as BSP. Later on APs can upload microcode from the saved microcodep patches.
Quoted 7 lines
Note, however, that Linux users have gotten used to being able to install a microcode patch in the field without having a reboot; we support that model too.
In
x86_64, this patchset needs early #PF handler set page table patchset. So this patchset is based on:git://git.kernel.org/pub/scm/linux/kernel/git/yinghai/linux-yinghai.gitfor-x86-boot
A couple of questions - why the usage of native_[read|write]_msr? I get the __native_cpuid variant, but I am not sure I understand why you are using the native_* variants. Especially as this code ends up being called on Xen and lguest (at least on 64-bit) and probably should go through the paravirt interfaces.
Also the same question for the __native_flush_tlb_global_irq_disabled
- you take parts of it out (the ones dealing with CR4) and end up calling those directly? Should they perhaps go through the paravirt interface?
Quoted 63 lines
v5: Call 64 bit
load_ucode_bsp()aftercopy_bootdata()and remove its parameter.v4: Change
CPUID_ISmacro. Callload_ucode_bspafterload_idtinx86_64. Flush tlb after applying microcode.v3: Change .hex to .bin in 01/10 and 05/10 patches. Fix some compilation warnings. In
x86_32mode, access global varialbes by__pa_symobl()and fix static string issue inx86_vendor(). Callload_ucode_ap()in real mode as well. Add debug info.v2: Detect vendor before loading microcode. Move some functions from
microcode_intel_early.ctomicrocode_intel_lib.c. Change some early loading microcode dependencies inKconfig. Reword doc.Fenghua Yu (12):
Documentation/x86: Early load microcodex86/microcode_intel.h: Define functions and macros for early loading
ucode
x86/common.c: Makehave_cpuid_p()a global functionx86/common.c: load ucode in 64 bit or show loading ucode info in 32
bit on AP
x86/microcode_core_early.c: Define interfaces for early loading ucodex86/microcode_intel_lib.c: Early update ucode on Intel's CPUx86/tlbflush.h: Define__native_flush_tlb_global_irq_disabled()x86/microcode_intel_early.c: Early update ucode on Intel's CPUx86/head_32.S: Early update ucode in 32-bit
x86/head64.c: Early update ucode in 64-bit
x86/mm/init.c: Copy ucode from initrd image to kernel memory x86/Kconfig: Configurations to enable/disable the featureDocumentation/x86/early-microcode.txt | 43 ++ arch/x86/Kconfig | 18 + arch/x86/include/asm/microcode.h | 14 + arch/x86/include/asm/microcode_intel.h | 85 ++++ arch/x86/include/asm/processor.h | 8 + arch/x86/include/asm/tlbflush.h | 18 +- arch/x86/kernel/Makefile | 3 + arch/x86/kernel/cpu/common.c | 17 +- arch/x86/kernel/head64.c | 6 + arch/x86/kernel/head_32.S | 11 + arch/x86/kernel/microcode_core.c | 7 +- arch/x86/kernel/microcode_core_early.c | 76 +++ arch/x86/kernel/microcode_intel.c | 198 ++------ arch/x86/kernel/microcode_intel_early.c | 796 ++++++++++++++++++++++++++++++++ arch/x86/kernel/microcode_intel_lib.c | 174 +++++++ arch/x86/mm/init.c | 10 + 16 files changed, 1301 insertions(+), 183 deletions(-) create mode 100644 Documentation/x86/early-microcode.txt create mode 100644 arch/x86/include/asm/microcode_intel.h create mode 100644 arch/x86/kernel/microcode_core_early.c create mode 100644 arch/x86/kernel/microcode_intel_early.c create mode 100644 arch/x86/kernel/microcode_intel_lib.cSignature · 7 lines
1.8.0.1 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
H. Peter Anvin
reviewerQuoted 7 lines · Konrad Rzeszutek Wilk
A couple of questions - why the usage of native_[read|write]_msr? I get the
__native_cpuidvariant, but I am not sure I understand why you are using the native_* variants. Especially as this code ends up being called on Xen and lguest (at least on 64-bit) and probably should go through the paravirt interfaces.
For Xen, the early microcode update should be done in the hypervisor launch.
However, if you have a more specific flow in mind please clarify. Keep in mind Xen is largely a black box to non-Xen developers (#include <stdrant.h>).
-hpa
P.S. Since when is lguest 64-bit? Did I miss something?
Signature · 2 lines
H. Peter Anvin, Intel Open Source Technology Center I work for Intel. I don't speak on their behalf.
Quoted 10 lines · H. Peter Anvin
Quoted 7 lines · Konrad Rzeszutek Wilk
A couple of questions - why the usage of native_[read|write]_msr? I get the
__native_cpuidvariant, but I am not sure I understand why you are using the native_* variants. Especially as this code ends up being called on Xen and lguest (at least on 64-bit) and probably should go through the paravirt interfaces.For Xen, the early microcode update should be done in the hypervisor launch.
Right. That is the plan.
Quoted 5 lines
However, if you have a more specific flow in mind please clarify.
Keep in mind Xen is largely a black box to non-Xen developers (#include <
stdrant.h>).
OK. I am trying to figure out whether this usage of native_* for the MSRs was done on purpose - and it sounds like the answer is no. If so - can it be done using the normal 'safe_rdmsr' and 'wrmsr'?
That would allow at least in the case of Xen, to omit a whole bunch of MSR writes/reads during the boot that are not neccessary as we would not trap in the hypervisor - but could use the pvops version of read/write MSR calls to just do a nop.
Quoted 4 lines
-hpa
P.S. Since when is lguest 64-bit? Did I miss something?
Oh, I assumed it could do it.
Quoted 11 lines
Signature · 9 lines
-- H. Peter Anvin, Intel Open Source Technology Center I work for Intel. I don't speak on their behalf. -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
H. Peter Anvin
reviewerQuoted 10 lines · Konrad Rzeszutek Wilk
OK. I am trying to figure out whether this usage of native_* for the MSRs was done on purpose - and it sounds like the answer is no. If so - can it be done using the normal '
safe_rdmsr' and 'wrmsr'?That would allow at least in the case of Xen, to omit a whole bunch of MSR writes/reads during the boot that are not neccessary as we would not trap in the hypervisor - but could use the pvops version of read/write MSR calls to just do a nop.
Why is this code invoked on Xen at all? That seems crazy.
-hpa
Quoted 6 lines · H. Peter Anvin
Quoted 5 lines · Konrad Rzeszutek Wilk
OK. I am trying to figure out whether this usage of native_* for the MSRs was done on purpose - and it sounds like the answer is no. If so - can it be done using the normal '
safe_rdmsr' and 'wrmsr'?
Quoted 7 lines
Quoted 5 lines
That would allow at least in the case of Xen, to omit a whole bunch of MSR writes/reads during the boot that are not neccessary as we would not trap in the hypervisor - but could use the pvops version of read/write MSR calls to just do a nop.
Why is this code invoked on Xen at all? That seems crazy.
[PATCH v4 09/11] x86/head64.c: Early update ucode in 64-bit
has this in x86_64_start_kernel:
..
load_idt((const struct desc_ptr *)&idt_descr);
+ /*
+ * Load microcode early on BSP.
+ */
+ load_ucode_bsp(__va(real_mode_data));
+
copy_bootdata(__va(real_mode_data));
Which gets called after xen_start_kernel has setup pagetables, bootparams, etc ready for the generic code to be invoked.
Or am I looking at an old version of these patches.
Quoted 4 lines
-hpa
H. Peter Anvin
reviewerQuoted 17 lines · Konrad Rzeszutek Wilk
Quoted 2 lines
Why is this code invoked on Xen at all? That seems crazy.
[PATCH v4 09/11]
x86/head64.c: Early update ucode in 64-bithas this in
x86_64_start_kernel:..
load_idt((const struct desc_ptr *)&idt_descr);(quoted diff) +5
-0+ /* + * Load microcode early on BSP. + */ + load_ucode_bsp(__va(real_mode_data)); + copy_bootdata(__va(real_mode_data));
Quoted 4 lines
Which gets called after
xen_start_kernelhas setup pagetables, bootparams, etc ready for the generic code to be invoked.Or am I looking at an old version of these patches.
We really shouldn't do that in that flow. This doesn't make sense on non-native.
-hpa
Quoted 29 lines · Konrad Rzeszutek Wilk
Quoted 6 lines · H. Peter Anvin
Quoted 5 lines · Konrad Rzeszutek Wilk
OK. I am trying to figure out whether this usage of native_* for the MSRs was done on purpose - and it sounds like the answer is no. If so - can it be done using the normal '
safe_rdmsr' and 'wrmsr'?Quoted 7 lines
Quoted 5 lines
That would allow at least in the case of Xen, to omit a whole bunch of MSR writes/reads during the boot that are not neccessary as we would not trap in the hypervisor - but could use the pvops version of read/write MSR calls to just do a nop.
Why is this code invoked on Xen at all? That seems crazy.
[PATCH v4 09/11]
x86/head64.c: Early update ucode in 64-bithas this in
x86_64_start_kernel:..
load_idt((const struct desc_ptr *)&idt_descr);(quoted diff) +5
-0+ /* + * Load microcode early on BSP. + */ + load_ucode_bsp(__va(real_mode_data)); + copy_bootdata(__va(real_mode_data));
Quoted 2 lines
Which gets called after
xen_start_kernelhas setup pagetables, bootparams, etc ready for the generic code to be invoked.
And I am looking at the wrong code. The "x86_64_start_kernel" is absolutly fine. It is "x86_64_start_reservations" that is invoked by Xen.
I got thrown off by the "copy_bootdata(.." which on v3.7 is in "x86_64_start_reservations".
Duh!
Quoted 6 lines
Or am I looking at an old version of these patches.
Quoted 4 lines
-hpa
[tip: x86/microcode] x86/microcode/32: Move early loading after paging enable
In reply to Fenghua YuThe 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: 3f320038de388fac90a402625cabd613c2797557 Gitweb: https://git.kernel.org/tip/3f320038de388fac90a402625cabd613c2797557 Author: Thomas Gleixner <[email protected]> AuthorDate: Mon, 02 Oct 2023 13:59:35 +02:00 Committer: Borislav Petkov (AMD) <[email protected]> CommitterDate: Mon, 02 Oct 2023 17:06:16 +02:00
x86/microcode/32: Move early loading after paging enable
32-bit loads microcode before paging is enabled. The commit which introduced that has zero justification in the changelog. The cover letter has slightly more content, but it does not give any technical justification either:
"The problem in current microcode loading method is that we load a
microcode way, way too late; ideally we should load it before turning paging on. This may only be practical on 32 bits since we can't get to 64-bit mode without paging on, but we should still do it as early as at all possible."
Handwaving word salad with zero technical content.
Someone claimed in an offlist conversation that this is required for curing the ATOM erratum AAE44/AAF40/AAG38/AAH41. That erratum requires an microcode update in order to make the usage of PSE safe. But during early boot PSE is completely irrelevant and it is evaluated way later.
Neither is it relevant for the AP on single core HT enabled CPUs as the microcode loading on the AP is not doing anything.
On dual core CPUs there is a theoretical problem if a split of an executable large page between enabling paging including PSE and loading the microcode happens. But that's only theoretical, it's practically irrelevant because the affected dual core CPUs are 64bit enabled and therefore have paging and PSE enabled before loading the microcode on the second core. So why would it work on 64-bit but not on 32-bit?
The erratum:
"AAG38 Code Fetch May Occur to Incorrect Address After a Large Page is
Split Into 4-Kbyte Pages
Problem: If software clears the PS (page size) bit in a present PDE (page directory entry), that will cause linear addresses mapped through this PDE to use 4-KByte pages instead of using a large page after old TLB entries are invalidated. Due to this erratum, if a code fetch uses this PDE before the TLB entry for the large page is invalidated then it may fetch from a different physical address than specified by either the old large page translation or the new 4-KByte page translation. This erratum may also cause speculative code fetches from incorrect addresses."
The practical relevance for this is exactly zero because there is no splitting of large text pages during early boot-time, i.e. between paging enable and microcode loading, and neither during CPU hotplug.
IOW, this load microcode before paging enable is yet another voodoo programming solution in search of a problem. What's worse is that it causes at least two serious problems:
1) When stackprotector is enabled then the microcode loader code has the stackprotector mechanics enabled. The read from the per CPU variable __stack_chk_guard is always accessing the virtual address either directly on UP or via FS on SMP. In physical address mode this results in an access to memory above 3GB. So this works by chance as the hardware returns the same value when there is no RAM at this physical address. When there is RAM populated above 3G then the read is by chance the same as nothing changes that memory during the very early boot stage. That's not necessarily true during runtime CPU hotplug.
2) When function tracing is enabled, then the relevant microcode loader functions and the functions invoked from there will call into the tracing code and evaluate global and per CPU variables in physical address mode. What could potentially go wrong?
Cure this and move the microcode loading after the early paging enable and remove the gunk in the microcode loader which is required to handle physical address mode.
--- arch/x86/include/asm/microcode.h | 5 +- arch/x86/kernel/cpu/common.c | 12 +-- arch/x86/kernel/cpu/microcode/amd.c | 103 ++++++-------------- arch/x86/kernel/cpu/microcode/core.c | 73 ++------------ arch/x86/kernel/cpu/microcode/intel.c | 116 +++------------------- arch/x86/kernel/cpu/microcode/internal.h | 2 +- arch/x86/kernel/head32.c | 3 +- arch/x86/kernel/head_32.S | 10 +-- arch/x86/kernel/smpboot.c | 12 +-- 9 files changed, 71 insertions(+), 265 deletions(-)
arch/x86/include/asm/microcode.h +0 -5
@@ -68,11 +68,6 @@ static inline u32 intel_get_microcode_revision(void)return rev; } - -void show_ucode_info_early (void ); - -#else /* CONFIG_CPU_SUP_INTEL */ -static inline void show_ucode_info_early (void ) { }#endif /* !CONFIG_CPU_SUP_INTEL */ #endif /* _ASM_X86_MICROCODE_H */
arch/x86/kernel/cpu/common.c +0 -12
@@ -2166,8 +2166,6 @@ static inline void setup_getcpu(int cpu) }#ifdef CONFIG_X86_64 -static inline void ucode_cpu_init (int cpu) { } -static inline void tss_setup_ist (struct tss_struct *tss) {/* Set up the per-CPU TSS IST stacks */
@@ -2178,16 +2176,8 @@ static inline void tss_setup_ist(struct tss_struct *tss)/* Only mapped when SEV-ES is active */ tss->x86_tss.ist[IST_INDEX_VC] = __this_cpu_ist_top_va(VC); } -#else /* CONFIG_X86_64 */ - -static inline void ucode_cpu_init (int cpu) -{ -show_ucode_info_early (); -} -static inline void tss_setup_ist (struct tss_struct *tss) { } -#endif /* !CONFIG_X86_64 */ static inline void tss_setup_io_bitmap (struct tss_struct *tss)
@@ -2243,8 +2233,6 @@ void cpu_init(void)struct task_struct *cur = current;int cpu =raw_smp_processor_id (); -ucode_cpu_init (cpu); -#ifdef CONFIG_NUMA if (this_cpu_read (numa_node) ==0 &&early_cpu_to_node (cpu) !=NUMA_NO_NODE )
arch/x86/kernel/cpu/microcode/amd.c +32 -71
255 lines not on this page · raw message
arch/x86/kernel/cpu/microcode/core.c +15 -58
142 lines not on this page · raw message
arch/x86/kernel/cpu/microcode/intel.c +16 -100
173 lines not on this page · raw message
arch/x86/kernel/cpu/microcode/internal.h +1 -1
@@ -44,7 +44,7 @@ struct microcode_ops { };extern struct ucode_cpu_info ucode_cpu_info[]; -struct cpio_data find_microcode_in_initrd (const char *path,bool use_pa); +struct cpio_data find_microcode_in_initrd (const char *path);#define MAX_UCODE_COUNT 128
arch/x86/kernel/head32.c +3 -0
@@ -19,6 +19,7 @@#include <asm/apic.h> #include <asm/io_apic.h> #include <asm/bios_ebda.h> +#include <asm/microcode.h> #include <asm/tlbflush.h> #include <asm/bootparam_utils.h>
@@ -34,6 +35,8 @@ asmlinkage __visible void __init __noreturn i386_start_kernel(void)/* Make sure IDT is set up before any exception happens */ idt_setup_early_handler (); +load_ucode_bsp (); +cr4_init_shadow ();sanitize_boot_params (&boot_params);
arch/x86/kernel/head_32.S +0 -10
@@ -118,11 +118,6 @@ SYM_CODE_START(startup_32) movl %eax, pa(olpc_ofw_pgd) #endif -#ifdef CONFIG_MICROCODE - /* Early load ucode on BSP. */ - call load_ucode_bsp -#endif - /* Create early pagetables. */ call mk_early_pgtbl_32
@@ -157,11 +152,6 @@ SYM_FUNC_START(startup_32_smp) movl %eax,%ss leal -__PAGE_OFFSET(%ecx),%esp -#ifdef CONFIG_MICROCODE - /* Early load ucode on AP. */ - call load_ucode_ap -#endif - .Ldefault_entry: movl $(CR0_STATE & ~X86_CR0_PG),%eax movl %eax,%cr0
arch/x86/kernel/smpboot.c +4 -8
@@ -258,12 +258,9 @@ static void notrace start_secondary(void *unused)cpu_init_exception_handling ();/* -* 32-bit systems load the microcode from the ASM startup code for -* historical reasons. -* -* On 64-bit systems load it before reaching the AP alive -* synchronization point below so it is not part of the full per -* CPU serialized bringup part when "parallel" bringup is enabled. +* Load the microcode before reaching the AP alive synchronization +* point below so it is not part of the full per CPU serialized +* bringup part when "parallel" bringup is enabled. * * That's even safe when hyperthreading is enabled in the CPU as * the core code starts the primary threads first and leaves the
@@ -276,8 +273,7 @@ static void notrace start_secondary(void *unused)* CPUID, MSRs etc. must be strictly serialized to maintain * software state correctness. */ -if (IS_ENABLED (CONFIG_X86_64 )) -load_ucode_ap (); +load_ucode_ap ();/* * Synchronization point with the hotplug core. Sets this CPUs