Release 4.7 arch/x86/kernel/cpu/microcode/core.c

Directory: arch/x86/kernel/cpu/microcode
/*
 * CPU Microcode Update Driver for Linux
 *
 * Copyright (C) 2000-2006 Tigran Aivazian <tigran@aivazian.fsnet.co.uk>
 *            2006      Shaohua Li <shaohua.li@intel.com>
 *            2013-2015 Borislav Petkov <bp@alien8.de>
 *
 * X86 CPU microcode early update for Linux:
 *
 *      Copyright (C) 2012 Fenghua Yu <fenghua.yu@intel.com>
 *                         H Peter Anvin" <hpa@zytor.com>
 *                (C) 2015 Borislav Petkov <bp@alien8.de>
 *
 * This driver allows to upgrade microcode on x86 processors.
 *
 * 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.
 */


#define pr_fmt(fmt) "microcode: " fmt

#include <linux/platform_device.h>
#include <linux/syscore_ops.h>
#include <linux/miscdevice.h>
#include <linux/capability.h>
#include <linux/firmware.h>
#include <linux/kernel.h>
#include <linux/mutex.h>
#include <linux/cpu.h>
#include <linux/fs.h>
#include <linux/mm.h>

#include <asm/microcode_intel.h>
#include <asm/cpu_device_id.h>
#include <asm/microcode_amd.h>
#include <asm/perf_event.h>
#include <asm/microcode.h>
#include <asm/processor.h>
#include <asm/cmdline.h>


#define MICROCODE_VERSION	"2.01"


static struct microcode_ops	*microcode_ops;

static bool dis_ucode_ldr;

/*
 * 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 bool __init check_loader_disabled_bsp(void)
{
	static const char *__dis_opt_str = "dis_ucode_ldr";

#ifdef CONFIG_X86_32
	const char *cmdline = (const char *)__pa_nodebug(boot_command_line);
	const char *option  = (const char *)__pa_nodebug(__dis_opt_str);
	bool *res = (bool *)__pa_nodebug(&dis_ucode_ldr);

#else /* CONFIG_X86_64 */
	const char *cmdline = boot_command_line;
	const char *option  = __dis_opt_str;
	bool *res = &dis_ucode_ldr;
#endif

	if (cmdline_find_option_bool(cmdline, option))
		*res = true;

	return *res;
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 108 100.00% 2 100.00%
Total 108 100.00% 2 100.00%

extern struct builtin_fw __start_builtin_fw[];
extern struct builtin_fw __end_builtin_fw[];



bool get_builtin_firmware(struct cpio_data *cd, const char *name)
{
#ifdef CONFIG_FW_LOADER
	struct builtin_fw *b_fw;

	for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
		if (!strcmp(name, b_fw->name)) {
			cd->size = b_fw->size;
			cd->data = b_fw->data;
			return true;
		}
	}
#endif
	return false;
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 76 100.00% 1 100.00%
Total 76 100.00% 1 100.00%



void __init load_ucode_bsp(void)
{
	int vendor;
	unsigned int family;

	if (check_loader_disabled_bsp())
		return;

	if (!have_cpuid_p())
		return;

	vendor = x86_cpuid_vendor();
	family = x86_cpuid_family();

	switch (vendor) {
	case X86_VENDOR_INTEL:
		if (family >= 6)
			load_ucode_intel_bsp();
		break;
	case X86_VENDOR_AMD:
		if (family >= 0x10)
			load_ucode_amd_bsp(family);
		break;
	default:
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 74 100.00% 2 100.00%
Total 74 100.00% 2 100.00%



static bool check_loader_disabled_ap(void)
{
#ifdef CONFIG_X86_32
	return *((bool *)__pa_nodebug(&dis_ucode_ldr));
#else
	return dis_ucode_ldr;
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%



void load_ucode_ap(void)
{
	int vendor, family;

	if (check_loader_disabled_ap())
		return;

	if (!have_cpuid_p())
		return;

	vendor = x86_cpuid_vendor();
	family = x86_cpuid_family();

	switch (vendor) {
	case X86_VENDOR_INTEL:
		if (family >= 6)
			load_ucode_intel_ap();
		break;
	case X86_VENDOR_AMD:
		if (family >= 0x10)
			load_ucode_amd_ap();
		break;
	default:
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 69 100.00% 2 100.00%
Total 69 100.00% 2 100.00%



int __init save_microcode_in_initrd(void)
{
	struct cpuinfo_x86 *c = &boot_cpu_data;

	switch (c->x86_vendor) {
	case X86_VENDOR_INTEL:
		if (c->x86 >= 6)
			save_microcode_in_initrd_intel();
		break;
	case X86_VENDOR_AMD:
		if (c->x86 >= 0x10)
			save_microcode_in_initrd_amd();
		break;
	default:
		break;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 59 100.00% 1 100.00%
Total 59 100.00% 1 100.00%



void reload_early_microcode(void)
{
	int vendor, family;

	vendor = x86_cpuid_vendor();
	family = x86_cpuid_family();

	switch (vendor) {
	case X86_VENDOR_INTEL:
		if (family >= 6)
			reload_ucode_intel();
		break;
	case X86_VENDOR_AMD:
		if (family >= 0x10)
			reload_ucode_amd();
		break;
	default:
		break;
	}
}

Contributors
Person Tokens Prop Commits CommitProp
borislav petkov borislav petkov 56 100.00% 2 100.00%
Total 56 100.00% 2 100.00%



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);
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 61 100.00% 1 100.00%
Total 61 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 60 100.00% 1 100.00%
Total 60 100.00% 1 100.00%


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());
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 51 100.00% 1 100.00%
Total 51 100.00% 1 100.00%

#ifdef CONFIG_MICROCODE_OLD_INTERFACE


static int do_microcode_update(const void __user *buf, size_t size)
{
	int error = 0;
	int cpu;

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

		if (!uci->valid)
			continue;

		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);
	}

	return error;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 50 54.35% 1 25.00%
dmitry adamushko dmitry adamushko 30 32.61% 2 50.00%
hugh dickins hugh dickins 12 13.04% 1 25.00%
Total 92 100.00% 4 100.00%



static int microcode_open(struct inode *inode, struct file *file)
{
	return capable(CAP_SYS_RAWIO) ? nonseekable_open(inode, file) : -EPERM;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 24 75.00% 1 50.00%
arnd bergmann arnd bergmann 8 25.00% 1 50.00%
Total 32 100.00% 2 100.00%



static ssize_t microcode_write(struct file *file, const char __user *buf,
			       size_t len, loff_t *ppos)
{
	ssize_t ret = -EINVAL;

	if ((len >> PAGE_SHIFT) > totalram_pages) {
		pr_err("too much data (max %ld pages)\n", totalram_pages);
		return ret;
	}

	get_online_cpus();
	mutex_lock(&microcode_mutex);

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

	if (ret > 0)
		perf_check_microcode();

	mutex_unlock(&microcode_mutex);
	put_online_cpus();

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 74 74.00% 1 16.67%
dmitry adamushko dmitry adamushko 14 14.00% 2 33.33%
stephane eranian stephane eranian 9 9.00% 1 16.67%
jan beulich jan beulich 2 2.00% 1 16.67%
joe perches joe perches 1 1.00% 1 16.67%
Total 100 100.00% 6 100.00%


static const struct file_operations microcode_fops = {
	.owner			= THIS_MODULE,
	.write			= microcode_write,
	.open			= microcode_open,
	.llseek		= no_llseek,
};


static struct miscdevice microcode_dev = {
	.minor			= MICROCODE_MINOR,
	.name			= "microcode",
	.nodename		= "cpu/microcode",
	.fops			= &microcode_fops,
};



static int __init microcode_dev_init(void)
{
	int error;

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 37 94.87% 1 33.33%
joe perches joe perches 1 2.56% 1 33.33%
dmitry adamushko dmitry adamushko 1 2.56% 1 33.33%
Total 39 100.00% 3 100.00%



static void __exit microcode_dev_exit(void)
{
	misc_deregister(&microcode_dev);
}
Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 14 93.33% 1 50.00%
srivatsa s. bhat srivatsa s. bhat 1 6.67% 1 50.00%
Total 15 100.00% 2 100.00%

#else

#define microcode_dev_init()	0

#define microcode_dev_exit()	do { } while (0)
#endif

/* fake device for request_firmware */

static struct platform_device	*microcode_pdev;



static int reload_for_cpu(int cpu)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;
	enum ucode_state ustate;
	int err = 0;

	if (!uci->valid)
		return err;

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

Contributors
Person Tokens Prop Commits CommitProp
rusty russell rusty russell 46 58.23% 1 25.00%
dmitry adamushko dmitry adamushko 23 29.11% 1 25.00%
borislav petkov borislav petkov 10 12.66% 2 50.00%
Total 79 100.00% 4 100.00%



static ssize_t reload_store(struct device *dev,
			    struct device_attribute *attr,
			    const char *buf, size_t size)
{
	unsigned long val;
	int cpu;
	ssize_t ret = 0, tmp_ret;

	ret = kstrtoul(buf, 0, &val);
	if (ret)
		return ret;

	if (val != 1)
		return size;

	get_online_cpus();
	mutex_lock(&microcode_mutex);
	for_each_online_cpu(cpu) {
		tmp_ret = reload_for_cpu(cpu);
		if (tmp_ret != 0)
			pr_warn("Error reloading microcode on CPU %d\n", cpu);

		/* save retval of the first encountered reload error */
		if (!ret)
			ret = tmp_ret;
	}
	if (!ret)
		perf_check_microcode();
	mutex_unlock(&microcode_mutex);
	put_online_cpus();

	if (!ret)
		ret = size;

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 46 32.86% 1 14.29%
borislav petkov borislav petkov 33 23.57% 1 14.29%
dmitry adamushko dmitry adamushko 31 22.14% 2 28.57%
peter zijlstra peter zijlstra 20 14.29% 1 14.29%
shuah khan shuah khan 8 5.71% 1 14.29%
kay sievers kay sievers 2 1.43% 1 14.29%
Total 140 100.00% 7 100.00%



static ssize_t version_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;

	return sprintf(buf, "0x%x\n", uci->cpu_sig.rev);
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 41 91.11% 1 33.33%
kay sievers kay sievers 2 4.44% 1 33.33%
dmitry adamushko dmitry adamushko 2 4.44% 1 33.33%
Total 45 100.00% 3 100.00%



static ssize_t pf_show(struct device *dev,
			struct device_attribute *attr, char *buf)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + dev->id;

	return sprintf(buf, "0x%x\n", uci->cpu_sig.pf);
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 41 91.11% 1 33.33%
kay sievers kay sievers 2 4.44% 1 33.33%
dmitry adamushko dmitry adamushko 2 4.44% 1 33.33%
Total 45 100.00% 3 100.00%

static DEVICE_ATTR(reload, 0200, NULL, reload_store);
static DEVICE_ATTR(version, 0400, version_show, NULL);
static DEVICE_ATTR(processor_flags, 0400, pf_show, NULL);


static struct attribute *mc_default_attrs[] = {
	&dev_attr_version.attr,
	&dev_attr_processor_flags.attr,
	NULL
};


static struct attribute_group mc_attr_group = {
	.attrs			= mc_default_attrs,
	.name			= "microcode",
};



static void microcode_fini_cpu(int cpu)
{
	microcode_ops->microcode_fini_cpu(cpu);
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 16 100.00% 3 100.00%
Total 16 100.00% 3 100.00%



static enum ucode_state microcode_resume_cpu(int cpu)
{
	pr_debug("CPU%d updated upon resume\n", cpu);

	if (apply_microcode_on_target(cpu))
		return UCODE_ERROR;

	return UCODE_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 23 76.67% 2 50.00%
borislav petkov borislav petkov 6 20.00% 1 25.00%
joe perches joe perches 1 3.33% 1 25.00%
Total 30 100.00% 4 100.00%



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->valid)
		return UCODE_OK;

	if (collect_cpu_info(cpu))
		return UCODE_ERROR;

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

	ustate = microcode_ops->request_microcode_fw(cpu, &microcode_pdev->dev,
						     refresh_fw);

	if (ustate == UCODE_OK) {
		pr_debug("CPU%d updated upon init\n", cpu);
		apply_microcode_on_target(cpu);
	}

	return ustate;
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 68 72.34% 3 42.86%
fenghua yu fenghua yu 18 19.15% 1 14.29%
borislav petkov borislav petkov 5 5.32% 1 14.29%
rusty russell rusty russell 2 2.13% 1 14.29%
joe perches joe perches 1 1.06% 1 14.29%
Total 94 100.00% 7 100.00%



static enum ucode_state microcode_update_cpu(int cpu)
{
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

	if (uci->valid)
		return microcode_resume_cpu(cpu);

	return microcode_init_cpu(cpu, false);
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 33 84.62% 3 50.00%
borislav petkov borislav petkov 5 12.82% 2 33.33%
rusty russell rusty russell 1 2.56% 1 16.67%
Total 39 100.00% 6 100.00%



static int mc_device_add(struct device *dev, struct subsys_interface *sif)
{
	int err, cpu = dev->id;

	if (!cpu_online(cpu))
		return 0;

	pr_debug("CPU%d added\n", cpu);

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

	if (microcode_init_cpu(cpu, true) == UCODE_ERROR)
		return -EINVAL;

	return err;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 58 71.60% 1 14.29%
kay sievers kay sievers 10 12.35% 1 14.29%
dmitry adamushko dmitry adamushko 7 8.64% 1 14.29%
borislav petkov borislav petkov 4 4.94% 2 28.57%
joe perches joe perches 1 1.23% 1 14.29%
rusty russell rusty russell 1 1.23% 1 14.29%
Total 81 100.00% 7 100.00%



static void mc_device_remove(struct device *dev, struct subsys_interface *sif)
{
	int cpu = dev->id;

	if (!cpu_online(cpu))
		return;

	pr_debug("CPU%d removed\n", cpu);
	microcode_fini_cpu(cpu);
	sysfs_remove_group(&dev->kobj, &mc_attr_group);
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 43 78.18% 1 25.00%
kay sievers kay sievers 9 16.36% 1 25.00%
viresh kumar viresh kumar 2 3.64% 1 25.00%
joe perches joe perches 1 1.82% 1 25.00%
Total 55 100.00% 4 100.00%


static struct subsys_interface mc_cpu_interface = {
	.name			= "microcode",
	.subsys			= &cpu_subsys,
	.add_dev		= mc_device_add,
	.remove_dev		= mc_device_remove,
};

/**
 * mc_bp_resume - Update boot CPU microcode during resume.
 */


static void mc_bp_resume(void)
{
	int cpu = smp_processor_id();
	struct ucode_cpu_info *uci = ucode_cpu_info + cpu;

	if (uci->valid && uci->mc)
		microcode_ops->apply_microcode(cpu);
	else if (!uci->mc)
		reload_early_microcode();
}

Contributors
Person Tokens Prop Commits CommitProp
dmitry adamushko dmitry adamushko 22 43.14% 1 20.00%
peter oruba peter oruba 13 25.49% 1 20.00%
borislav petkov borislav petkov 11 21.57% 2 40.00%
rafael j. wysocki rafael j. wysocki 5 9.80% 1 20.00%
Total 51 100.00% 5 100.00%


static struct syscore_ops mc_syscore_ops = {
	.resume			= mc_bp_resume,
};


static int

mc_cpu_callback(struct notifier_block *nb, unsigned long action, void *hcpu)
{
	unsigned int cpu = (unsigned long)hcpu;
	struct device *dev;

	dev = get_cpu_device(cpu);

	switch (action & ~CPU_TASKS_FROZEN) {
	case CPU_ONLINE:
		microcode_update_cpu(cpu);
		pr_debug("CPU%d added\n", cpu);
		/*
                 * "break" is missing on purpose here because we want to fall
                 * through in order to create the sysfs group.
                 */

	case CPU_DOWN_FAILED:
		if (sysfs_create_group(&dev->kobj, &mc_attr_group))
			pr_err("Failed to create group for CPU%d\n", cpu);
		break;

	case CPU_DOWN_PREPARE:
		/* Suspend is in progress, only remove the interface */
		sysfs_remove_group(&dev->kobj, &mc_attr_group);
		pr_debug("CPU%d removed\n", cpu);
		break;

	/*
         * case CPU_DEAD:
         *
         * When a CPU goes offline, don't free up or invalidate the copy of
         * the microcode in kernel memory, so that we can reuse it when the
         * CPU comes back online without unnecessarily requesting the userspace
         * for it again.
         */
	}

	/* The CPU refused to come up during a system resume */
	if (action == CPU_UP_CANCELED_FROZEN)
		microcode_fini_cpu(cpu);

	return NOTIFY_OK;
}

Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 84 65.12% 1 14.29%
dmitry adamushko dmitry adamushko 18 13.95% 2 28.57%
borislav petkov borislav petkov 15 11.63% 1 14.29%
kay sievers kay sievers 6 4.65% 1 14.29%
joe perches joe perches 3 2.33% 1 14.29%
rusty russell rusty russell 3 2.33% 1 14.29%
Total 129 100.00% 7 100.00%


static struct notifier_block mc_cpu_notifier = {
	.notifier_call	= mc_cpu_callback,
};


static struct attribute *cpu_root_microcode_attrs[] = {
	&dev_attr_reload.attr,
	NULL
};


static struct attribute_group cpu_root_microcode_group = {
	.name  = "microcode",
	.attrs = cpu_root_microcode_attrs,
};



int __init microcode_init(void)
{
	struct cpuinfo_x86 *c = &boot_cpu_data;
	int error;

	if (dis_ucode_ldr)
		return -EINVAL;

	if (c->x86_vendor == X86_VENDOR_INTEL)
		microcode_ops = init_intel_microcode();
	else if (c->x86_vendor == X86_VENDOR_AMD)
		microcode_ops = init_amd_microcode();
	else
		pr_err("no support for this CPU vendor\n");

	if (!microcode_ops)
		return -ENODEV;

	microcode_pdev = platform_device_register_simple("microcode", -1,
							 NULL, 0);
	if (IS_ERR(microcode_pdev))
		return PTR_ERR(microcode_pdev);

	get_online_cpus();
	mutex_lock(&microcode_mutex);

	error = subsys_interface_register(&mc_cpu_interface);
	if (!error)
		perf_check_microcode();
	mutex_unlock(&microcode_mutex);
	put_online_cpus();

	if (error)
		goto out_pdev;

	error = sysfs_create_group(&cpu_subsys.dev_root->kobj,
				   &cpu_root_microcode_group);

	if (error) {
		pr_err("Error creating microcode group!\n");
		goto out_driver;
	}

	error = microcode_dev_init();
	if (error)
		goto out_ucode_group;

	register_syscore_ops(&mc_syscore_ops);
	register_hotcpu_notifier(&mc_cpu_notifier);

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

	return 0;

 out_ucode_group:
	sysfs_remove_group(&cpu_subsys.dev_root->kobj,
			   &cpu_root_microcode_group);

 out_driver:
	get_online_cpus();
	mutex_lock(&microcode_mutex);

	subsys_interface_unregister(&mc_cpu_interface);

	mutex_unlock(&microcode_mutex);
	put_online_cpus();

 out_pdev:
	platform_device_unregister(microcode_pdev);
	return error;

}
Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 80 31.87% 3 18.75%
dmitry adamushko dmitry adamushko 52 20.72% 2 12.50%
borislav petkov borislav petkov 52 20.72% 3 18.75%
srivatsa s. bhat srivatsa s. bhat 38 15.14% 1 6.25%
peter zijlstra peter zijlstra 8 3.19% 1 6.25%
rafael j. wysocki rafael j. wysocki 6 2.39% 1 6.25%
andreas herrmann andreas herrmann 6 2.39% 1 6.25%
greg kroah-hartman greg kroah-hartman 3 1.20% 1 6.25%
joe perches joe perches 2 0.80% 1 6.25%
boris ostrovsky boris ostrovsky 2 0.80% 1 6.25%
kay sievers kay sievers 2 0.80% 1 6.25%
Total 251 100.00% 16 100.00%


late_initcall(microcode_init);
Overall Contributors
Person Tokens Prop Commits CommitProp
peter oruba peter oruba 809 33.54% 4 8.33%
borislav petkov borislav petkov 689 28.57% 16 33.33%
dmitry adamushko dmitry adamushko 601 24.92% 6 12.50%
kay sievers kay sievers 60 2.49% 3 6.25%
rusty russell rusty russell 53 2.20% 1 2.08%
srivatsa s. bhat srivatsa s. bhat 39 1.62% 1 2.08%
peter zijlstra peter zijlstra 30 1.24% 1 2.08%
rafael j. wysocki rafael j. wysocki 28 1.16% 1 2.08%
fenghua yu fenghua yu 18 0.75% 1 2.08%
joe perches joe perches 17 0.70% 1 2.08%
arnd bergmann arnd bergmann 13 0.54% 2 4.17%
hugh dickins hugh dickins 12 0.50% 1 2.08%
stephane eranian stephane eranian 9 0.37% 1 2.08%
shuah khan shuah khan 8 0.33% 1 2.08%
ingo molnar ingo molnar 7 0.29% 1 2.08%
andreas herrmann andreas herrmann 6 0.25% 1 2.08%
greg kroah-hartman greg kroah-hartman 3 0.12% 1 2.08%
jan beulich jan beulich 2 0.08% 1 2.08%
viresh kumar viresh kumar 2 0.08% 1 2.08%
hannes eder hannes eder 2 0.08% 1 2.08%
boris ostrovsky boris ostrovsky 2 0.08% 1 2.08%
andi kleen andi kleen 2 0.08% 1 2.08%
Total 2412 100.00% 48 100.00%
  Directory: arch/x86/kernel/cpu/microcode

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
borislav petkov	borislav petkov	108	100.00%	2	100.00%
	Total	108	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 arch/x86/kernel/cpu/microcode/core.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
