Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754679Ab2FMUVq (ORCPT ); Wed, 13 Jun 2012 16:21:46 -0400 Received: from mga09.intel.com ([134.134.136.24]:31269 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750910Ab2FMUUp (ORCPT ); Wed, 13 Jun 2012 16:20:45 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.67,351,1309762800"; d="scan'208";a="157260955" From: Andi Kleen To: x86@kernel.org Cc: linux-kernel@vger.kernel.org, eranian@google.com, peterz@infradead.org, Andi Kleen Subject: [PATCH 1/4] x86: Do microcode updates at CPU_STARTING, not CPU_ONLINE Date: Wed, 13 Jun 2012 13:20:39 -0700 Message-Id: <1339618842-26636-2-git-send-email-andi@firstfloor.org> X-Mailer: git-send-email 1.7.7.6 In-Reply-To: <1339618842-26636-1-git-send-email-andi@firstfloor.org> References: <1339618842-26636-1-git-send-email-andi@firstfloor.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 5205 Lines: 174 From: Andi Kleen Do microcode updates of resuming or newling plugged CPUs earlier in CPU_STARTING instead of later when ONLINE. This prevents races with parallel users who may need a microcode update to avoid some problem. Since we cannot request the microcode from udev at this stage, try to grab the microcode from another CPU. This is also more efficient because it avoids redundant loads. In addition to that it avoids the need for separate paths for resume and CPU bootup. This requires invalidating the microcodes on other CPUs on free. Each CPU does this in parallel, so it's not a big problem. When there is no good microcode available the update is delayed until the update can be requested. In the normal cases it should be available. Signed-off-by: Andi Kleen --- arch/x86/kernel/microcode_core.c | 65 +++++++++++++++++++++++++------------ arch/x86/kernel/microcode_intel.c | 13 +++++++- 2 files changed, 56 insertions(+), 22 deletions(-) diff --git a/arch/x86/kernel/microcode_core.c b/arch/x86/kernel/microcode_core.c index fbdfc69..f947ef7 100644 --- a/arch/x86/kernel/microcode_core.c +++ b/arch/x86/kernel/microcode_core.c @@ -358,20 +358,7 @@ static void microcode_fini_cpu(int cpu) uci->valid = 0; } -static enum ucode_state microcode_resume_cpu(int cpu) -{ - struct ucode_cpu_info *uci = ucode_cpu_info + cpu; - - if (!uci->mc) - return UCODE_NFOUND; - - pr_debug("CPU%d updated upon resume\n", cpu); - apply_microcode_on_target(cpu); - - return UCODE_OK; -} - -static enum ucode_state microcode_init_cpu(int cpu) +static enum ucode_state microcode_init_cpu_late(int cpu) { enum ucode_state ustate; @@ -392,15 +379,44 @@ static enum ucode_state microcode_init_cpu(int cpu) return ustate; } -static enum ucode_state microcode_update_cpu(int cpu) +/* Grab ucode from another CPU */ +static void clone_ucode_data(void) +{ + int cpu = smp_processor_id(); + int i; + + for_each_online_cpu (i) { + if (ucode_cpu_info[i].mc && + ucode_cpu_info[i].valid && + cpu_data(i).x86 == cpu_data(cpu).x86 && + cpu_data(i).x86_model == cpu_data(cpu).x86_model) { + ucode_cpu_info[cpu].mc = ucode_cpu_info[i].mc; + break; + } + } +} + +static enum ucode_state microcode_init_cpu_early(int cpu) +{ + clone_ucode_data(); + /* We can request later when the CPU is online */ + if (ucode_cpu_info[cpu].mc == NULL) + return UCODE_ERROR; + if (microcode_ops->collect_cpu_info(cpu, &ucode_cpu_info[cpu].cpu_sig)) + return UCODE_ERROR; + if (microcode_ops->apply_microcode(smp_processor_id())) + pr_warn("CPU%d microcode update failed\n", cpu); + return UCODE_OK; +} + +static enum ucode_state microcode_update_cpu_late(int cpu) { struct ucode_cpu_info *uci = ucode_cpu_info + cpu; enum ucode_state ustate; - if (uci->valid) - ustate = microcode_resume_cpu(cpu); - else - ustate = microcode_init_cpu(cpu); + /* Resume already done early */ + if (!uci->valid) + ustate = microcode_init_cpu_late(cpu); return ustate; } @@ -418,7 +434,7 @@ static int mc_device_add(struct device *dev, struct subsys_interface *sif) if (err) return err; - if (microcode_init_cpu(cpu) == UCODE_ERROR) + if (microcode_init_cpu_late(cpu) == UCODE_ERROR) return -EINVAL; return err; @@ -468,9 +484,16 @@ mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu) dev = get_cpu_device(cpu); switch (action) { + case CPU_STARTING: + case CPU_STARTING_FROZEN: + microcode_init_cpu_early(cpu); + break; + case CPU_ONLINE: case CPU_ONLINE_FROZEN: - microcode_update_cpu(cpu); + /* Retry again in case we couldn't request early */ + if (cpu_data(cpu).microcode < ucode_cpu_info[cpu].cpu_sig.rev) + microcode_update_cpu_late(cpu); case CPU_DOWN_FAILED: case CPU_DOWN_FAILED_FROZEN: pr_debug("CPU%d added\n", cpu); diff --git a/arch/x86/kernel/microcode_intel.c b/arch/x86/kernel/microcode_intel.c index 0327e2b..899057b 100644 --- a/arch/x86/kernel/microcode_intel.c +++ b/arch/x86/kernel/microcode_intel.c @@ -329,6 +329,16 @@ static int apply_microcode(int cpu) return 0; } +static void invalidate_microcode(void *data) +{ + int i; + + for_each_possible_cpu (i) { + if (ucode_cpu_info[i].mc == data) + ucode_cpu_info[i].mc = NULL; + } +} + static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, int (*get_ucode_data)(void *, const void *, size_t)) { @@ -391,6 +401,7 @@ static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size, } vfree(uci->mc); + invalidate_microcode(uci->mc); uci->mc = (struct microcode_intel *)new_mc; pr_debug("CPU%d found a matching microcode update with version 0x%x (current=0x%x)\n", @@ -444,7 +455,7 @@ static void microcode_fini_cpu(int cpu) struct ucode_cpu_info *uci = ucode_cpu_info + cpu; vfree(uci->mc); - uci->mc = NULL; + invalidate_microcode(uci->mc); } static struct microcode_ops microcode_intel_ops = { -- 1.7.7.6 -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/