x86: microcode: use smp_call_function_single instead of set_cpus_allowed,... (871b72dd) · Commits · 戴 / test

arch/x86/include/asm/microcode.h

+18 −7

Original line number	Diff line number	Diff line
		@@ -9,14 +9,25 @@ struct cpu_signature {

		struct device;

		enum ucode_state { UCODE_ERROR, UCODE_OK, UCODE_NFOUND };

		struct microcode_ops {
		int (request_microcode_user) (int cpu, const void __user buf, size_t size);
		int (request_microcode_fw) (int cpu, struct device device);
		enum ucode_state (*request_microcode_user) (int cpu,
		const void __user *buf, size_t size);

		void (*apply_microcode) (int cpu);
		enum ucode_state (*request_microcode_fw) (int cpu,
		struct device *device);

		int (collect_cpu_info) (int cpu, struct cpu_signature csig);
		void (*microcode_fini_cpu) (int cpu);

		/*
		* The generic 'microcode_core' part guarantees that
		* the callbacks below run on a target cpu when they
		* are being called.
		* See also the "Synchronization" section in microcode_core.c.
		*/
		int (*apply_microcode) (int cpu);
		int (collect_cpu_info) (int cpu, struct cpu_signature csig);
		};

		struct ucode_cpu_info {

arch/x86/kernel/microcode_amd.c

+22 −36

Original line number	Diff line number	Diff line
		@@ -13,25 +13,13 @@
		* Licensed under the terms of the GNU General Public
		* License version 2. See file COPYING for details.
		*/
		#include <linux/platform_device.h>
		#include <linux/capability.h>
		#include <linux/miscdevice.h>
		#include <linux/firmware.h>
		#include <linux/spinlock.h>
		#include <linux/cpumask.h>
		#include <linux/pci_ids.h>
		#include <linux/uaccess.h>
		#include <linux/vmalloc.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/mutex.h>
		#include <linux/sched.h>
		#include <linux/init.h>
		#include <linux/slab.h>
		#include <linux/cpu.h>
		#include <linux/pci.h>
		#include <linux/fs.h>
		#include <linux/mm.h>

		#include <asm/microcode.h>
		#include <asm/processor.h>
		@@ -79,9 +67,6 @@ struct microcode_amd {
		#define UCODE_CONTAINER_SECTION_HDR 8
		#define UCODE_CONTAINER_HEADER_SIZE 12

		/* serialize access to the physical write */
		static DEFINE_SPINLOCK(microcode_update_lock);

		static struct equiv_cpu_entry *equiv_cpu_table;

		static int collect_cpu_info_amd(int cpu, struct cpu_signature *csig)
		@@ -144,9 +129,8 @@ static int get_matching_microcode(int cpu, void *mc, int rev)
		return 1;
		}

		static void apply_microcode_amd(int cpu)
		static int apply_microcode_amd(int cpu)
		{
		unsigned long flags;
		u32 rev, dummy;
		int cpu_num = raw_smp_processor_id();
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu_num;
		@@ -156,25 +140,25 @@ static void apply_microcode_amd(int cpu)
		BUG_ON(cpu_num != cpu);

		if (mc_amd == NULL)
		return;
		return 0;

		spin_lock_irqsave(&microcode_update_lock, flags);
		wrmsrl(MSR_AMD64_PATCH_LOADER, (u64)(long)&mc_amd->hdr.data_code);
		/* get patch id after patching */
		rdmsr(MSR_AMD64_PATCH_LEVEL, rev, dummy);
		spin_unlock_irqrestore(&microcode_update_lock, flags);

		/* check current patch id and patch's id for match */
		if (rev != mc_amd->hdr.patch_id) {
		printk(KERN_ERR "microcode: CPU%d: update failed "
		"(for patch_level=0x%x)\n", cpu, mc_amd->hdr.patch_id);
		return;
		return -1;
		}

		printk(KERN_INFO "microcode: CPU%d: updated (new patch_level=0x%x)\n",
		cpu, rev);

		uci->cpu_sig.rev = rev;

		return 0;
		}

		static int get_ucode_data(void to, const u8 from, size_t n)
		@@ -263,7 +247,8 @@ static void free_equiv_cpu_table(void)
		}
		}

		static int generic_load_microcode(int cpu, const u8 *data, size_t size)
		static enum ucode_state
		generic_load_microcode(int cpu, const u8 *data, size_t size)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		const u8 *ucode_ptr = data;
		@@ -272,12 +257,13 @@ static int generic_load_microcode(int cpu, const u8 *data, size_t size)
		int new_rev = uci->cpu_sig.rev;
		unsigned int leftover;
		unsigned long offset;
		enum ucode_state state = UCODE_OK;

		offset = install_equiv_cpu_table(ucode_ptr);
		if (!offset) {
		printk(KERN_ERR "microcode: failed to create "
		"equivalent cpu table\n");
		return -EINVAL;
		return UCODE_ERROR;
		}

		ucode_ptr += offset;
		@@ -312,28 +298,27 @@ static int generic_load_microcode(int cpu, const u8 *data, size_t size)
		pr_debug("microcode: CPU%d found a matching microcode "
		"update with version 0x%x (current=0x%x)\n",
		cpu, new_rev, uci->cpu_sig.rev);
		} else
		} else {
		vfree(new_mc);
		state = UCODE_ERROR;
		}
		} else
		state = UCODE_NFOUND;

		free_equiv_cpu_table();

		return (int)leftover;
		return state;
		}

		static int request_microcode_fw(int cpu, struct device *device)
		static enum ucode_state request_microcode_fw(int cpu, struct device *device)
		{
		const char *fw_name = "amd-ucode/microcode_amd.bin";
		const struct firmware *firmware;
		int ret;

		/* We should bind the task to the CPU */
		BUG_ON(cpu != raw_smp_processor_id());
		enum ucode_state ret;

		ret = request_firmware(&firmware, fw_name, device);
		if (ret) {
		if (request_firmware(&firmware, fw_name, device)) {
		printk(KERN_ERR "microcode: failed to load file %s\n", fw_name);
		return ret;
		return UCODE_NFOUND;
		}

		ret = generic_load_microcode(cpu, firmware->data, firmware->size);
		@@ -343,11 +328,12 @@ static int request_microcode_fw(int cpu, struct device *device)
		return ret;
		}

		static int request_microcode_user(int cpu, const void __user *buf, size_t size)
		static enum ucode_state
		request_microcode_user(int cpu, const void __user *buf, size_t size)
		{
		printk(KERN_INFO "microcode: AMD microcode update via "
		"/dev/cpu/microcode not supported\n");
		return -1;
		return UCODE_ERROR;
		}

		static void microcode_fini_cpu_amd(int cpu)

arch/x86/kernel/microcode_core.c

+189 −140

Original line number	Diff line number	Diff line
		@@ -71,27 +71,18 @@
		* Thanks to Stuart Swales for pointing out this bug.
		*/
		#include <linux/platform_device.h>
		#include <linux/capability.h>
		#include <linux/miscdevice.h>
		#include <linux/firmware.h>
		#include <linux/capability.h>
		#include <linux/smp_lock.h>
		#include <linux/spinlock.h>
		#include <linux/cpumask.h>
		#include <linux/uaccess.h>
		#include <linux/vmalloc.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/mutex.h>
		#include <linux/sched.h>
		#include <linux/init.h>
		#include <linux/slab.h>
		#include <linux/cpu.h>
		#include <linux/fs.h>
		#include <linux/mm.h>

		#include <asm/microcode.h>
		#include <asm/processor.h>
		#include <asm/msr.h>

		MODULE_DESCRIPTION("Microcode Update Driver");
		MODULE_AUTHOR("Tigran Aivazian <tigran@aivazian.fsnet.co.uk>");
		@@ -101,36 +92,110 @@ MODULE_LICENSE("GPL");

		static struct microcode_ops *microcode_ops;

		/* no concurrent ->write()s are allowed on /dev/cpu/microcode */
		/*
		* Synchronization.
		*
		* All non cpu-hotplug-callback call sites use:
		*
		* - microcode_mutex to synchronize with each other;
		* - get/put_online_cpus() to synchronize with
		* the cpu-hotplug-callback call sites.
		*
		* We guarantee that only a single cpu is being
		* updated at any particular moment of time.
		*/
		static DEFINE_MUTEX(microcode_mutex);

		struct ucode_cpu_info ucode_cpu_info[NR_CPUS];
		EXPORT_SYMBOL_GPL(ucode_cpu_info);

		/*
		* Operations that are run on a target cpu:
		*/

		struct cpu_info_ctx {
		struct cpu_signature *cpu_sig;
		int err;
		};

		static void collect_cpu_info_local(void *arg)
		{
		struct cpu_info_ctx *ctx = arg;

		ctx->err = microcode_ops->collect_cpu_info(smp_processor_id(),
		ctx->cpu_sig);
		}

		static int collect_cpu_info_on_target(int cpu, struct cpu_signature *cpu_sig)
		{
		struct cpu_info_ctx ctx = { .cpu_sig = cpu_sig, .err = 0 };
		int ret;

		ret = smp_call_function_single(cpu, collect_cpu_info_local, &ctx, 1);
		if (!ret)
		ret = ctx.err;

		return ret;
		}

		static int collect_cpu_info(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		int ret;

		memset(uci, 0, sizeof(*uci));

		ret = collect_cpu_info_on_target(cpu, &uci->cpu_sig);
		if (!ret)
		uci->valid = 1;

		return ret;
		}

		struct apply_microcode_ctx {
		int err;
		};

		static void apply_microcode_local(void *arg)
		{
		struct apply_microcode_ctx *ctx = arg;

		ctx->err = microcode_ops->apply_microcode(smp_processor_id());
		}

		static int apply_microcode_on_target(int cpu)
		{
		struct apply_microcode_ctx ctx = { .err = 0 };
		int ret;

		ret = smp_call_function_single(cpu, apply_microcode_local, &ctx, 1);
		if (!ret)
		ret = ctx.err;

		return ret;
		}

		#ifdef CONFIG_MICROCODE_OLD_INTERFACE
		static int do_microcode_update(const void __user *buf, size_t size)
		{
		cpumask_t old;
		int error = 0;
		int cpu;

		old = current->cpus_allowed;

		for_each_online_cpu(cpu) {
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		enum ucode_state ustate;

		if (!uci->valid)
		continue;

		set_cpus_allowed_ptr(current, &cpumask_of_cpu(cpu));
		error = microcode_ops->request_microcode_user(cpu, buf, size);
		if (error < 0)
		goto out;
		if (!error)
		microcode_ops->apply_microcode(cpu);
		ustate = microcode_ops->request_microcode_user(cpu, buf, size);
		if (ustate == UCODE_ERROR) {
		error = -1;
		break;
		} else if (ustate == UCODE_OK)
		apply_microcode_on_target(cpu);
		}
		out:
		set_cpus_allowed_ptr(current, &old);

		return error;
		}

		@@ -143,19 +208,17 @@ static int microcode_open(struct inode unused1, struct file unused2)
		static ssize_t microcode_write(struct file file, const char __user buf,
		size_t len, loff_t *ppos)
		{
		ssize_t ret;
		ssize_t ret = -EINVAL;

		if ((len >> PAGE_SHIFT) > num_physpages) {
		printk(KERN_ERR "microcode: too much data (max %ld pages)\n",
		num_physpages);
		return -EINVAL;
		pr_err("microcode: too much data (max %ld pages)\n", num_physpages);
		return ret;
		}

		get_online_cpus();
		mutex_lock(&microcode_mutex);

		ret = do_microcode_update(buf, len);
		if (!ret)
		if (do_microcode_update(buf, len) == 0)
		ret = (ssize_t)len;

		mutex_unlock(&microcode_mutex);
		@@ -182,9 +245,7 @@ static int __init microcode_dev_init(void)

		error = misc_register(&microcode_dev);
		if (error) {
		printk(KERN_ERR
		"microcode: can't misc_register on minor=%d\n",
		MICROCODE_MINOR);
		pr_err("microcode: can't misc_register on minor=%d\n", MICROCODE_MINOR);
		return error;
		}

		@@ -205,42 +266,51 @@ MODULE_ALIAS_MISCDEV(MICROCODE_MINOR);
		/* fake device for request_firmware */
		static struct platform_device *microcode_pdev;

		static long reload_for_cpu(void *unused)
		static int reload_for_cpu(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + smp_processor_id();
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		int err = 0;

		mutex_lock(&microcode_mutex);
		if (uci->valid) {
		err = microcode_ops->request_microcode_fw(smp_processor_id(),
		&microcode_pdev->dev);
		if (!err)
		microcode_ops->apply_microcode(smp_processor_id());
		enum ucode_state ustate;

		ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);
		if (ustate == UCODE_OK)
		apply_microcode_on_target(cpu);
		else
		if (ustate == UCODE_ERROR)
		err = -EINVAL;
		}
		mutex_unlock(&microcode_mutex);

		return err;
		}

		static ssize_t reload_store(struct sys_device *dev,
		struct sysdev_attribute *attr,
		const char *buf, size_t sz)
		const char *buf, size_t size)
		{
		char *end;
		unsigned long val = simple_strtoul(buf, &end, 0);
		int err = 0;
		unsigned long val;
		int cpu = dev->id;
		int ret = 0;
		char *end;

		val = simple_strtoul(buf, &end, 0);
		if (end == buf)
		return -EINVAL;

		if (val == 1) {
		get_online_cpus();
		if (cpu_online(cpu))
		err = work_on_cpu(cpu, reload_for_cpu, NULL);
		ret = reload_for_cpu(cpu);
		put_online_cpus();
		}
		if (err)
		return err;
		return sz;

		if (!ret)
		ret = size;

		return ret;
		}

		static ssize_t version_show(struct sys_device *dev,
		@@ -275,7 +345,7 @@ static struct attribute_group mc_attr_group = {
		.name = "microcode",
		};

		static void __microcode_fini_cpu(int cpu)
		static void microcode_fini_cpu(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

		@@ -283,103 +353,68 @@ static void __microcode_fini_cpu(int cpu)
		uci->valid = 0;
		}

		static void microcode_fini_cpu(int cpu)
		{
		mutex_lock(&microcode_mutex);
		__microcode_fini_cpu(cpu);
		mutex_unlock(&microcode_mutex);
		}

		static void collect_cpu_info(int cpu)
		static enum ucode_state microcode_resume_cpu(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

		memset(uci, 0, sizeof(*uci));
		if (!microcode_ops->collect_cpu_info(cpu, &uci->cpu_sig))
		uci->valid = 1;
		if (!uci->mc)
		return UCODE_NFOUND;

		pr_debug("microcode: CPU%d updated upon resume\n", cpu);
		apply_microcode_on_target(cpu);

		return UCODE_OK;
		}

		static int microcode_resume_cpu(int cpu)
		static enum ucode_state microcode_init_cpu(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		struct cpu_signature nsig;
		enum ucode_state ustate;

		pr_debug("microcode: CPU%d resumed\n", cpu);
		if (collect_cpu_info(cpu))
		return UCODE_ERROR;

		if (!uci->mc)
		return 1;
		/* --dimm. Trigger a delayed update? */
		if (system_state != SYSTEM_RUNNING)
		return UCODE_NFOUND;

		/*
		* Let's verify that the 'cached' ucode does belong
		* to this cpu (a bit of paranoia):
		*/
		if (microcode_ops->collect_cpu_info(cpu, &nsig)) {
		__microcode_fini_cpu(cpu);
		printk(KERN_ERR "failed to collect_cpu_info for resuming cpu #%d\n",
		cpu);
		return -1;
		}
		ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev);

		if ((nsig.sig != uci->cpu_sig.sig) \|\| (nsig.pf != uci->cpu_sig.pf)) {
		__microcode_fini_cpu(cpu);
		printk(KERN_ERR "cached ucode doesn't match the resuming cpu #%d\n",
		cpu);
		/* Should we look for a new ucode here? */
		return 1;
		if (ustate == UCODE_OK) {
		pr_debug("microcode: CPU%d updated upon init\n", cpu);
		apply_microcode_on_target(cpu);
		}

		return 0;
		return ustate;
		}

		static long microcode_update_cpu(void *unused)
		static enum ucode_state microcode_update_cpu(int cpu)
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + smp_processor_id();
		int err = 0;

		/*
		* Check if the system resume is in progress (uci->valid != NULL),
		* otherwise just request a firmware:
		*/
		if (uci->valid) {
		err = microcode_resume_cpu(smp_processor_id());
		} else {
		collect_cpu_info(smp_processor_id());
		if (uci->valid && system_state == SYSTEM_RUNNING)
		err = microcode_ops->request_microcode_fw(
		smp_processor_id(),
		&microcode_pdev->dev);
		}
		if (!err)
		microcode_ops->apply_microcode(smp_processor_id());
		return err;
		}
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		enum ucode_state ustate;

		static int microcode_init_cpu(int cpu)
		{
		int err;
		mutex_lock(&microcode_mutex);
		err = work_on_cpu(cpu, microcode_update_cpu, NULL);
		mutex_unlock(&microcode_mutex);
		if (uci->valid)
		ustate = microcode_resume_cpu(cpu);
		else
		ustate = microcode_init_cpu(cpu);

		return err;
		return ustate;
		}

		static int mc_sysdev_add(struct sys_device *sys_dev)
		{
		int err, cpu = sys_dev->id;
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

		if (!cpu_online(cpu))
		return 0;

		pr_debug("microcode: CPU%d added\n", cpu);
		memset(uci, 0, sizeof(*uci));

		err = sysfs_create_group(&sys_dev->kobj, &mc_attr_group);
		if (err)
		return err;

		err = microcode_init_cpu(cpu);
		if (microcode_init_cpu(cpu) == UCODE_ERROR)
		err = -EINVAL;

		return err;
		}
		@@ -400,12 +435,23 @@ static int mc_sysdev_remove(struct sys_device *sys_dev)
		static int mc_sysdev_resume(struct sys_device *dev)
		{
		int cpu = dev->id;
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

		if (!cpu_online(cpu))
		return 0;

		/* only CPU 0 will apply ucode here */
		microcode_update_cpu(NULL);
		/*
		* All non-bootup cpus are still disabled,
		* so only CPU 0 will apply ucode here.
		*
		* Moreover, there can be no concurrent
		* updates from any other places at this point.
		*/
		WARN_ON(cpu != 0);

		if (uci->valid && uci->mc)
		microcode_ops->apply_microcode(cpu);

		return 0;
		}

		@@ -425,15 +471,12 @@ mc_cpu_callback(struct notifier_block nb, unsigned long action, void hcpu)
		switch (action) {
		case CPU_ONLINE:
		case CPU_ONLINE_FROZEN:
		if (microcode_init_cpu(cpu))
		printk(KERN_ERR "microcode: failed to init CPU%d\n",
		cpu);
		microcode_update_cpu(cpu);
		case CPU_DOWN_FAILED:
		case CPU_DOWN_FAILED_FROZEN:
		pr_debug("microcode: CPU%d added\n", cpu);
		if (sysfs_create_group(&sys_dev->kobj, &mc_attr_group))
		printk(KERN_ERR "microcode: Failed to create the sysfs "
		"group for CPU%d\n", cpu);
		pr_err("microcode: Failed to create group for CPU%d\n", cpu);
		break;
		case CPU_DOWN_PREPARE:
		case CPU_DOWN_PREPARE_FROZEN:
		@@ -465,13 +508,10 @@ static int __init microcode_init(void)
		microcode_ops = init_amd_microcode();

		if (!microcode_ops) {
		printk(KERN_ERR "microcode: no support for this CPU vendor\n");
		pr_err("microcode: no support for this CPU vendor\n");
		return -ENODEV;
		}

		error = microcode_dev_init();
		if (error)
		return error;
		microcode_pdev = platform_device_register_simple("microcode", -1,
		NULL, 0);
		if (IS_ERR(microcode_pdev)) {
		@@ -480,23 +520,31 @@ static int __init microcode_init(void)
		}

		get_online_cpus();
		mutex_lock(&microcode_mutex);

		error = sysdev_driver_register(&cpu_sysdev_class, &mc_sysdev_driver);

		mutex_unlock(&microcode_mutex);
		put_online_cpus();

		if (error) {
		microcode_dev_exit();
		platform_device_unregister(microcode_pdev);
		return error;
		}

		error = microcode_dev_init();
		if (error)
		return error;

		register_hotcpu_notifier(&mc_cpu_notifier);

		printk(KERN_INFO
		"Microcode Update Driver: v" MICROCODE_VERSION
		pr_info("Microcode Update Driver: v" MICROCODE_VERSION
		" <tigran@aivazian.fsnet.co.uk>,"
		" Peter Oruba\n");

		return 0;
		}
		module_init(microcode_init);

		static void __exit microcode_exit(void)
		{
		@@ -505,16 +553,17 @@ static void __exit microcode_exit(void)
		unregister_hotcpu_notifier(&mc_cpu_notifier);

		get_online_cpus();
		mutex_lock(&microcode_mutex);

		sysdev_driver_unregister(&cpu_sysdev_class, &mc_sysdev_driver);

		mutex_unlock(&microcode_mutex);
		put_online_cpus();

		platform_device_unregister(microcode_pdev);

		microcode_ops = NULL;

		printk(KERN_INFO
		"Microcode Update Driver: v" MICROCODE_VERSION " removed.\n");
		pr_info("Microcode Update Driver: v" MICROCODE_VERSION " removed.\n");
		}

		module_init(microcode_init);
		module_exit(microcode_exit);

arch/x86/kernel/microcode_intel.c

+33 −57

Original line number	Diff line number	Diff line
		@@ -70,24 +70,11 @@
		* Fix sigmatch() macro to handle old CPUs with pf == 0.
		* Thanks to Stuart Swales for pointing out this bug.
		*/
		#include <linux/platform_device.h>
		#include <linux/capability.h>
		#include <linux/miscdevice.h>
		#include <linux/firmware.h>
		#include <linux/smp_lock.h>
		#include <linux/spinlock.h>
		#include <linux/cpumask.h>
		#include <linux/uaccess.h>
		#include <linux/vmalloc.h>
		#include <linux/kernel.h>
		#include <linux/module.h>
		#include <linux/mutex.h>
		#include <linux/sched.h>
		#include <linux/init.h>
		#include <linux/slab.h>
		#include <linux/cpu.h>
		#include <linux/fs.h>
		#include <linux/mm.h>
		#include <linux/vmalloc.h>

		#include <asm/microcode.h>
		#include <asm/processor.h>
		@@ -150,13 +137,9 @@ struct extended_sigtable {

		#define exttable_size(et) ((et)->count * EXT_SIGNATURE_SIZE + EXT_HEADER_SIZE)

		/* serialize access to the physical write to MSR 0x79 */
		static DEFINE_SPINLOCK(microcode_update_lock);

		static int collect_cpu_info(int cpu_num, struct cpu_signature *csig)
		{
		struct cpuinfo_x86 *c = &cpu_data(cpu_num);
		unsigned long flags;
		unsigned int val[2];

		memset(csig, 0, sizeof(*csig));
		@@ -176,18 +159,14 @@ static int collect_cpu_info(int cpu_num, struct cpu_signature *csig)
		csig->pf = 1 << ((val[1] >> 18) & 7);
		}

		/* serialize access to the physical write to MSR 0x79 */
		spin_lock_irqsave(&microcode_update_lock, flags);

		wrmsr(MSR_IA32_UCODE_REV, 0, 0);
		/* see notes above for revision 1.07. Apparent chip bug */
		sync_core();
		/* get the current revision from MSR 0x8B */
		rdmsr(MSR_IA32_UCODE_REV, val[0], csig->rev);
		spin_unlock_irqrestore(&microcode_update_lock, flags);

		pr_debug("microcode: collect_cpu_info : sig=0x%x, pf=0x%x, rev=0x%x\n",
		csig->sig, csig->pf, csig->rev);
		printk(KERN_INFO "microcode: CPU%d sig=0x%x, pf=0x%x, revision=0x%x\n",
		cpu_num, csig->sig, csig->pf, csig->rev);

		return 0;
		}
		@@ -318,11 +297,10 @@ get_matching_microcode(struct cpu_signature cpu_sig, void mc, int rev)
		return 0;
		}

		static void apply_microcode(int cpu)
		static int apply_microcode(int cpu)
		{
		struct microcode_intel *mc_intel;
		struct ucode_cpu_info *uci;
		unsigned long flags;
		unsigned int val[2];
		int cpu_num;

		@@ -334,10 +312,7 @@ static void apply_microcode(int cpu)
		BUG_ON(cpu_num != cpu);

		if (mc_intel == NULL)
		return;

		/* serialize access to the physical write to MSR 0x79 */
		spin_lock_irqsave(&microcode_update_lock, flags);
		return 0;

		/* write microcode via MSR 0x79 */
		wrmsr(MSR_IA32_UCODE_WRITE,
		@@ -351,30 +326,32 @@ static void apply_microcode(int cpu)
		/* get the current revision from MSR 0x8B */
		rdmsr(MSR_IA32_UCODE_REV, val[0], val[1]);

		spin_unlock_irqrestore(&microcode_update_lock, flags);
		if (val[1] != mc_intel->hdr.rev) {
		printk(KERN_ERR "microcode: CPU%d update from revision "
		"0x%x to 0x%x failed\n",
		cpu_num, uci->cpu_sig.rev, val[1]);
		return;
		}
		printk(KERN_INFO "microcode: CPU%d updated from revision "
		"0x%x to 0x%x, date = %04x-%02x-%02x \n",
		cpu_num, uci->cpu_sig.rev, val[1],
		printk(KERN_ERR "microcode: CPU%d update "
		"to revision 0x%x failed\n",
		cpu_num, mc_intel->hdr.rev);
		return -1;
		}
		printk(KERN_INFO "microcode: CPU%d updated to revision "
		"0x%x, date = %04x-%02x-%02x \n",
		cpu_num, val[1],
		mc_intel->hdr.date & 0xffff,
		mc_intel->hdr.date >> 24,
		(mc_intel->hdr.date >> 16) & 0xff);

		uci->cpu_sig.rev = val[1];

		return 0;
		}

		static int generic_load_microcode(int cpu, void *data, size_t size,
		static enum ucode_state generic_load_microcode(int cpu, void *data, size_t size,
		int (get_ucode_data)(void , const void *, size_t))
		{
		struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
		u8 ucode_ptr = data, new_mc = NULL, *mc;
		int new_rev = uci->cpu_sig.rev;
		unsigned int leftover = size;
		enum ucode_state state = UCODE_OK;

		while (leftover) {
		struct microcode_header_intel mc_header;
		@@ -412,11 +389,15 @@ static int generic_load_microcode(int cpu, void *data, size_t size,
		leftover -= mc_size;
		}

		if (!new_mc)
		goto out;

		if (leftover) {
		if (new_mc)
		vfree(new_mc);
		state = UCODE_ERROR;
		goto out;
		}

		if (!new_mc) {
		state = UCODE_NFOUND;
		goto out;
		}

		@@ -427,9 +408,8 @@ static int generic_load_microcode(int cpu, void *data, size_t size,
		pr_debug("microcode: CPU%d found a matching microcode update with"
		" version 0x%x (current=0x%x)\n",
		cpu, new_rev, uci->cpu_sig.rev);

		out:
		return (int)leftover;
		return state;
		}

		static int get_ucode_fw(void to, const void from, size_t n)
		@@ -438,21 +418,19 @@ static int get_ucode_fw(void to, const void from, size_t n)
		return 0;
		}

		static int request_microcode_fw(int cpu, struct device *device)
		static enum ucode_state request_microcode_fw(int cpu, struct device *device)
		{
		char name[30];
		struct cpuinfo_x86 *c = &cpu_data(cpu);
		const struct firmware *firmware;
		int ret;
		enum ucode_state ret;

		/* We should bind the task to the CPU */
		BUG_ON(cpu != raw_smp_processor_id());
		sprintf(name, "intel-ucode/%02x-%02x-%02x",
		c->x86, c->x86_model, c->x86_mask);
		ret = request_firmware(&firmware, name, device);
		if (ret) {

		if (request_firmware(&firmware, name, device)) {
		pr_debug("microcode: data file %s load failed\n", name);
		return ret;
		return UCODE_NFOUND;
		}

		ret = generic_load_microcode(cpu, (void *)firmware->data,
		@@ -468,11 +446,9 @@ static int get_ucode_user(void to, const void from, size_t n)
		return copy_from_user(to, from, n);
		}

		static int request_microcode_user(int cpu, const void __user *buf, size_t size)
		static enum ucode_state
		request_microcode_user(int cpu, const void __user *buf, size_t size)
		{
		/* We should bind the task to the CPU */
		BUG_ON(cpu != raw_smp_processor_id());

		return generic_load_microcode(cpu, (void *)buf, size, &get_ucode_user);
		}

Admin message