Release 4.10 drivers/base/cpu.c

Directory: drivers/base
/*
 * CPU subsystem support
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/cpu.h>
#include <linux/topology.h>
#include <linux/device.h>
#include <linux/node.h>
#include <linux/gfp.h>
#include <linux/slab.h>
#include <linux/percpu.h>
#include <linux/acpi.h>
#include <linux/of.h>
#include <linux/cpufeature.h>
#include <linux/tick.h>

#include "base.h"

static DEFINE_PER_CPU(struct device *, cpu_sys_devices);



static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
{
	/* ACPI style match is the only one that may succeed. */
	if (acpi_driver_match_device(dev, drv))
		return 1;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
rafael j. wysocki rafael j. wysocki 32 100.00% 1 100.00%
Total 32 100.00% 1 100.00%

#ifdef CONFIG_HOTPLUG_CPU


static void change_cpu_under_node(struct cpu *cpu,
			unsigned int from_nid, unsigned int to_nid)
{
	int cpuid = cpu->dev.id;
	unregister_cpu_under_node(cpuid, from_nid);
	register_cpu_under_node(cpuid, to_nid);
	cpu->node_id = to_nid;
}

Contributors
Person Tokens Prop Commits CommitProp
yasuaki ishimatsu yasuaki ishimatsu 48 100.00% 1 100.00%
Total 48 100.00% 1 100.00%



static int cpu_subsys_online(struct device *dev)
{
	struct cpu *cpu = container_of(dev, struct cpu, dev);
	int cpuid = dev->id;
	int from_nid, to_nid;
	int ret;

	from_nid = cpu_to_node(cpuid);
	if (from_nid == NUMA_NO_NODE)
		return -ENODEV;

	ret = cpu_up(cpuid);
	/*
         * When hot adding memory to memoryless node and enabling a cpu
         * on the node, node number of the cpu may internally change.
         */
	to_nid = cpu_to_node(cpuid);
	if (from_nid != to_nid)
		change_cpu_under_node(cpu, from_nid, to_nid);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
yasuaki ishimatsu yasuaki ishimatsu 40 43.96% 1 16.67%
rusty russell rusty russell 34 37.36% 1 16.67%
rafael j. wysocki rafael j. wysocki 11 12.09% 2 33.33%
toshi kani toshi kani 4 4.40% 1 16.67%
kay sievers kay sievers 2 2.20% 1 16.67%
Total 91 100.00% 6 100.00%



static int cpu_subsys_offline(struct device *dev)
{
	return cpu_down(dev->id);
}

Contributors
Person Tokens Prop Commits CommitProp
rusty russell rusty russell 9 47.37% 1 25.00%
rafael j. wysocki rafael j. wysocki 8 42.11% 1 25.00%
kay sievers kay sievers 1 5.26% 1 25.00%
toshi kani toshi kani 1 5.26% 1 25.00%
Total 19 100.00% 4 100.00%



void unregister_cpu(struct cpu *cpu)
{
	int logical_cpu = cpu->dev.id;

	unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));

	device_unregister(&cpu->dev);
	per_cpu(cpu_sys_devices, logical_cpu) = NULL;
	return;
}

Contributors
Person Tokens Prop Commits CommitProp
len brown len brown 23 48.94% 1 20.00%
ashok raj ashok raj 13 27.66% 1 20.00%
kamezawa hiroyuki kamezawa hiroyuki 4 8.51% 1 20.00%
mike travis mike travis 4 8.51% 1 20.00%
kay sievers kay sievers 3 6.38% 1 20.00%
Total 47 100.00% 5 100.00%

#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE


static ssize_t cpu_probe_store(struct device *dev,
			       struct device_attribute *attr,
			       const char *buf,
			       size_t count)
{
	ssize_t cnt;
	int ret;

	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

	cnt = arch_cpu_probe(buf, count);

	unlock_device_hotplug();
	return cnt;
}

Contributors
Person Tokens Prop Commits CommitProp
toshi kani toshi kani 25 43.86% 1 25.00%
nathan fontenot nathan fontenot 25 43.86% 1 25.00%
andi kleen andi kleen 4 7.02% 1 25.00%
kay sievers kay sievers 3 5.26% 1 25.00%
Total 57 100.00% 4 100.00%



static ssize_t cpu_release_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf,
				 size_t count)
{
	ssize_t cnt;
	int ret;

	ret = lock_device_hotplug_sysfs();
	if (ret)
		return ret;

	cnt = arch_cpu_release(buf, count);

	unlock_device_hotplug();
	return cnt;
}

Contributors
Person Tokens Prop Commits CommitProp
toshi kani toshi kani 25 43.86% 1 25.00%
nathan fontenot nathan fontenot 25 43.86% 1 25.00%
andi kleen andi kleen 4 7.02% 1 25.00%
kay sievers kay sievers 3 5.26% 1 25.00%
Total 57 100.00% 4 100.00%

static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
#endif /* CONFIG_HOTPLUG_CPU */


struct bus_type cpu_subsys = {
	.name = "cpu",
	.dev_name = "cpu",
	.match = cpu_subsys_match,
#ifdef CONFIG_HOTPLUG_CPU
	.online = cpu_subsys_online,
	.offline = cpu_subsys_offline,
#endif
};

EXPORT_SYMBOL_GPL(cpu_subsys);

#ifdef CONFIG_KEXEC
#include <linux/kexec.h>



static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
				char *buf)
{
	struct cpu *cpu = container_of(dev, struct cpu, dev);
	ssize_t rc;
	unsigned long long addr;
	int cpunum;

	cpunum = cpu->dev.id;

	/*
         * Might be reading other cpu's data based on which cpu read thread
         * has been scheduled. But cpu data (memory) is allocated once during
         * boot up and this data does not change there after. Hence this
         * operation should be safe. No locking required.
         */
	addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
	rc = sprintf(buf, "%Lx\n", addr);
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
vivek goyal vivek goyal 73 90.12% 2 50.00%
andi kleen andi kleen 4 4.94% 1 25.00%
kay sievers kay sievers 4 4.94% 1 25.00%
Total 81 100.00% 4 100.00%

static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);



static ssize_t show_crash_notes_size(struct device *dev,
				     struct device_attribute *attr,
				     char *buf)
{
	ssize_t rc;

	rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
	return rc;
}
Contributors
Person Tokens Prop Commits CommitProp
zhang yanfei zhang yanfei 39 97.50% 1 50.00%
arnd bergmann arnd bergmann 1 2.50% 1 50.00%
Total 40 100.00% 2 100.00%

static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);


static struct attribute *crash_note_cpu_attrs[] = {
	&dev_attr_crash_notes.attr,
	&dev_attr_crash_notes_size.attr,
	NULL
};


static struct attribute_group crash_note_cpu_attr_group = {
	.attrs = crash_note_cpu_attrs,
};
#endif


static const struct attribute_group *common_cpu_attr_groups[] = {
#ifdef CONFIG_KEXEC
	&crash_note_cpu_attr_group,
#endif
	NULL
};


static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
#ifdef CONFIG_KEXEC
	&crash_note_cpu_attr_group,
#endif
	NULL
};

/*
 * Print cpu online, possible, present, and system maps
 */


struct cpu_attr {
	
struct device_attribute attr;
	
const struct cpumask *const map;
};



static ssize_t show_cpus_attr(struct device *dev,
			      struct device_attribute *attr,
			      char *buf)
{
	struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);

	return cpumap_print_to_pagebuf(true, buf, ca->map);
}

Contributors
Person Tokens Prop Commits CommitProp
andi kleen andi kleen 24 51.06% 1 20.00%
mike travis mike travis 15 31.91% 1 20.00%
sudeep holla sudeep holla 4 8.51% 1 20.00%
kay sievers kay sievers 3 6.38% 1 20.00%
rusty russell rusty russell 1 2.13% 1 20.00%
Total 47 100.00% 5 100.00%


#define _CPU_ATTR(name, map) \
	{ __ATTR(name, 0444, show_cpus_attr, NULL), map }

/* Keep in sync with cpu_subsys_attrs */

static struct cpu_attr cpu_attrs[] = {
	_CPU_ATTR(online, &__cpu_online_mask),
	_CPU_ATTR(possible, &__cpu_possible_mask),
	_CPU_ATTR(present, &__cpu_present_mask),
};

/*
 * Print values for NR_CPUS and offlined cpus
 */


static ssize_t print_cpus_kernel_max(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
	return n;
}
Contributors
Person Tokens Prop Commits CommitProp
mike travis mike travis 34 82.93% 2 50.00%
andi kleen andi kleen 4 9.76% 1 25.00%
kay sievers kay sievers 3 7.32% 1 25.00%
Total 41 100.00% 4 100.00%

static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);

/* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */

unsigned int total_cpus;



static ssize_t print_cpus_offline(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	int n = 0, len = PAGE_SIZE-2;
	cpumask_var_t offline;

	/* display offline cpus < nr_cpu_ids */
	if (!alloc_cpumask_var(&offline, GFP_KERNEL))
		return -ENOMEM;
	cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
	n = scnprintf(buf, len, "%*pbl", cpumask_pr_args(offline));
	free_cpumask_var(offline);

	/* display offline cpus >= nr_cpu_ids */
	if (total_cpus && nr_cpu_ids < total_cpus) {
		if (n && n < len)
			buf[n++] = ',';

		if (nr_cpu_ids == total_cpus-1)
			n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
		else
			n += snprintf(&buf[n], len - n, "%d-%d",
						      nr_cpu_ids, total_cpus-1);
	}

	n += snprintf(&buf[n], len - n, "\n");
	return n;
}
Contributors
Person Tokens Prop Commits CommitProp
mike travis mike travis 162 91.01% 1 20.00%
tejun heo tejun heo 6 3.37% 1 20.00%
andi kleen andi kleen 4 2.25% 1 20.00%
jan beulich jan beulich 3 1.69% 1 20.00%
kay sievers kay sievers 3 1.69% 1 20.00%
Total 178 100.00% 5 100.00%

static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);



static ssize_t print_cpus_isolated(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	int n = 0, len = PAGE_SIZE-2;

	n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(cpu_isolated_map));

	return n;
}
Contributors
Person Tokens Prop Commits CommitProp
rik van riel rik van riel 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%

static DEVICE_ATTR(isolated, 0444, print_cpus_isolated, NULL);

#ifdef CONFIG_NO_HZ_FULL


static ssize_t print_cpus_nohz_full(struct device *dev,
				  struct device_attribute *attr, char *buf)
{
	int n = 0, len = PAGE_SIZE-2;

	n = scnprintf(buf, len, "%*pbl\n", cpumask_pr_args(tick_nohz_full_mask));

	return n;
}
Contributors
Person Tokens Prop Commits CommitProp
rik van riel rik van riel 50 100.00% 1 100.00%
Total 50 100.00% 1 100.00%

static DEVICE_ATTR(nohz_full, 0444, print_cpus_nohz_full, NULL);
#endif



static void cpu_device_release(struct device *dev)
{
	/*
         * This is an empty function to prevent the driver core from spitting a
         * warning at us.  Yes, I know this is directly opposite of what the
         * documentation for the driver core and kobjects say, and the author
         * of this code has already been publically ridiculed for doing
         * something as foolish as this.  However, at this point in time, it is
         * the only way to handle the issue of statically allocated cpu
         * devices.  The different architectures will have their cpu device
         * code reworked to properly handle this in the near future, so this
         * function will then be changed to correctly free up the memory held
         * by the cpu device.
         *
         * Never copy this way of doing things, or you too will be made fun of
         * on the linux-kernel list, you have been warned.
         */
}

Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 11 91.67% 1 50.00%
ralf baechle ralf baechle 1 8.33% 1 50.00%
Total 12 100.00% 2 100.00%

#ifdef CONFIG_GENERIC_CPU_AUTOPROBE


static ssize_t print_cpu_modalias(struct device *dev,
				  struct device_attribute *attr,
				  char *buf)
{
	ssize_t n;
	u32 i;

	n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
		    CPU_FEATURE_TYPEVAL);

	for (i = 0; i < MAX_CPU_FEATURES; i++)
		if (cpu_have_feature(i)) {
			if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
				WARN(1, "CPU features overflow page\n");
				break;
			}
			n += sprintf(&buf[n], ",%04X", i);
		}
	buf[n++] = '\n';
	return n;
}

Contributors
Person Tokens Prop Commits CommitProp
ard biesheuvel ard biesheuvel 108 100.00% 1 100.00%
Total 108 100.00% 1 100.00%



static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
{
	char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
	if (buf) {
		print_cpu_modalias(NULL, NULL, buf);
		add_uevent_var(env, "MODALIAS=%s", buf);
		kfree(buf);
	}
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
ard biesheuvel ard biesheuvel 59 100.00% 1 100.00%
Total 59 100.00% 1 100.00%

#endif

/*
 * register_cpu - Setup a sysfs device for a CPU.
 * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
 *        sysfs for this CPU.
 * @num - CPU number to use when creating the device.
 *
 * Initialize and register the CPU device.
 */


int register_cpu(struct cpu *cpu, int num)
{
	int error;

	cpu->node_id = cpu_to_node(num);
	memset(&cpu->dev, 0x00, sizeof(struct device));
	cpu->dev.id = num;
	cpu->dev.bus = &cpu_subsys;
	cpu->dev.release = cpu_device_release;
	cpu->dev.offline_disabled = !cpu->hotpluggable;
	cpu->dev.offline = !cpu_online(num);
	cpu->dev.of_node = of_get_cpu_node(num, NULL);
#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
	cpu->dev.bus->uevent = cpu_uevent;
#endif
	cpu->dev.groups = common_cpu_attr_groups;
	if (cpu->hotpluggable)
		cpu->dev.groups = hotplugable_cpu_attr_groups;
	error = device_register(&cpu->dev);
	if (error)
		return error;

	per_cpu(cpu_sys_devices, num) = &cpu->dev;
	register_cpu_under_node(num, cpu_to_node(num));

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 40 22.10% 4 17.39%
greg kroah-hartman greg kroah-hartman 26 14.36% 3 13.04%
igor mammedov igor mammedov 22 12.15% 2 8.70%
thomas renninger thomas renninger 13 7.18% 1 4.35%
ashok raj ashok raj 13 7.18% 2 8.70%
sudeep karkadanagesha sudeep karkadanagesha 13 7.18% 1 4.35%
toshi kani toshi kani 12 6.63% 1 4.35%
rafael j. wysocki rafael j. wysocki 11 6.08% 1 4.35%
kamezawa hiroyuki kamezawa hiroyuki 10 5.52% 1 4.35%
kay sievers kay sievers 5 2.76% 1 4.35%
rusty russell rusty russell 5 2.76% 1 4.35%
mike travis mike travis 4 2.21% 1 4.35%
alex shi alex shi 4 2.21% 1 4.35%
ard biesheuvel ard biesheuvel 2 1.10% 2 8.70%
suresh siddha suresh siddha 1 0.55% 1 4.35%
Total 181 100.00% 23 100.00%



struct device *get_cpu_device(unsigned cpu)
{
	if (cpu < nr_cpu_ids && cpu_possible(cpu))
		return per_cpu(cpu_sys_devices, cpu);
	else
		return NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
ashok raj ashok raj 20 60.61% 1 25.00%
mike travis mike travis 10 30.30% 1 25.00%
kay sievers kay sievers 2 6.06% 1 25.00%
andrew morton andrew morton 1 3.03% 1 25.00%
Total 33 100.00% 4 100.00%


EXPORT_SYMBOL_GPL(get_cpu_device);



static void device_create_release(struct device *dev)
{
	kfree(dev);
}

Contributors
Person Tokens Prop Commits CommitProp
sudeep holla sudeep holla 16 100.00% 1 100.00%
Total 16 100.00% 1 100.00%


static struct device *

__cpu_device_create(struct device *parent, void *drvdata,
		    const struct attribute_group **groups,
		    const char *fmt, va_list args)
{
	struct device *dev = NULL;
	int retval = -ENODEV;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev) {
		retval = -ENOMEM;
		goto error;
	}

	device_initialize(dev);
	dev->parent = parent;
	dev->groups = groups;
	dev->release = device_create_release;
	dev_set_drvdata(dev, drvdata);

	retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
	if (retval)
		goto error;

	retval = device_add(dev);
	if (retval)
		goto error;

	return dev;

error:
	put_device(dev);
	return ERR_PTR(retval);
}

Contributors
Person Tokens Prop Commits CommitProp
sudeep holla sudeep holla 154 100.00% 1 100.00%
Total 154 100.00% 1 100.00%



struct device *cpu_device_create(struct device *parent, void *drvdata,
				 const struct attribute_group **groups,
				 const char *fmt, ...)
{
	va_list vargs;
	struct device *dev;

	va_start(vargs, fmt);
	dev = __cpu_device_create(parent, drvdata, groups, fmt, vargs);
	va_end(vargs);
	return dev;
}
Contributors
Person Tokens Prop Commits CommitProp
sudeep holla sudeep holla 68 100.00% 1 100.00%
Total 68 100.00% 1 100.00%


EXPORT_SYMBOL_GPL(cpu_device_create);

#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
#endif


static struct attribute *cpu_root_attrs[] = {
#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
	&dev_attr_probe.attr,
	&dev_attr_release.attr,
#endif
	&cpu_attrs[0].attr.attr,
	&cpu_attrs[1].attr.attr,
	&cpu_attrs[2].attr.attr,
	&dev_attr_kernel_max.attr,
	&dev_attr_offline.attr,
	&dev_attr_isolated.attr,
#ifdef CONFIG_NO_HZ_FULL
	&dev_attr_nohz_full.attr,
#endif
#ifdef CONFIG_GENERIC_CPU_AUTOPROBE
	&dev_attr_modalias.attr,
#endif
	NULL
};


static struct attribute_group cpu_root_attr_group = {
	.attrs = cpu_root_attrs,
};


static const struct attribute_group *cpu_root_attr_groups[] = {
	&cpu_root_attr_group,
	NULL,
};



bool cpu_is_hotpluggable(unsigned cpu)
{
	struct device *dev = get_cpu_device(cpu);
	return dev && container_of(dev, struct cpu, dev)->hotpluggable;
}
Contributors
Person Tokens Prop Commits CommitProp
josh triplett josh triplett 30 90.91% 1 50.00%
linus torvalds linus torvalds 3 9.09% 1 50.00%
Total 33 100.00% 2 100.00%


EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);

#ifdef CONFIG_GENERIC_CPU_DEVICES
static DEFINE_PER_CPU(struct cpu, cpu_devices);
#endif



static void __init cpu_dev_register_generic(void)
{
#ifdef CONFIG_GENERIC_CPU_DEVICES
	int i;

	for_each_possible_cpu(i) {
		if (register_cpu(&per_cpu(cpu_devices, i), i))
			panic("Failed to register CPU device");
	}
#endif
}

Contributors
Person Tokens Prop Commits CommitProp
ben hutchings ben hutchings 43 100.00% 1 100.00%
Total 43 100.00% 1 100.00%



void __init cpu_dev_init(void)
{
	if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
		panic("Failed to register CPU subsystem");

	cpu_dev_register_generic();
}
Contributors
Person Tokens Prop Commits CommitProp
ben hutchings ben hutchings 11 42.31% 2 33.33%
patrick mochel patrick mochel 10 38.46% 3 50.00%
kay sievers kay sievers 5 19.23% 1 16.67%
Total 26 100.00% 6 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
mike travis mike travis 279 13.27% 4 6.25%
sudeep holla sudeep holla 247 11.75% 2 3.12%
ard biesheuvel ard biesheuvel 180 8.56% 2 3.12%
rik van riel rik van riel 147 6.99% 2 3.12%
andi kleen andi kleen 129 6.14% 5 7.81%
rafael j. wysocki rafael j. wysocki 107 5.09% 3 4.69%
igor mammedov igor mammedov 95 4.52% 2 3.12%
kay sievers kay sievers 95 4.52% 1 1.56%
vivek goyal vivek goyal 92 4.38% 2 3.12%
yasuaki ishimatsu yasuaki ishimatsu 88 4.19% 1 1.56%
nathan fontenot nathan fontenot 78 3.71% 1 1.56%
ben hutchings ben hutchings 74 3.52% 2 3.12%
toshi kani toshi kani 67 3.19% 3 4.69%
rusty russell rusty russell 58 2.76% 2 3.12%
ashok raj ashok raj 52 2.47% 2 3.12%
zhang yanfei zhang yanfei 51 2.43% 1 1.56%
andrew morton andrew morton 43 2.05% 5 7.81%
thomas renninger thomas renninger 40 1.90% 1 1.56%
greg kroah-hartman greg kroah-hartman 37 1.76% 3 4.69%
josh triplett josh triplett 35 1.67% 1 1.56%
len brown len brown 23 1.09% 1 1.56%
patrick mochel patrick mochel 20 0.95% 4 6.25%
kamezawa hiroyuki kamezawa hiroyuki 17 0.81% 1 1.56%
sudeep karkadanagesha sudeep karkadanagesha 16 0.76% 1 1.56%
tejun heo tejun heo 9 0.43% 2 3.12%
alex shi alex shi 4 0.19% 1 1.56%
al viro al viro 3 0.14% 1 1.56%
linus torvalds linus torvalds 3 0.14% 1 1.56%
rasmus villemoes rasmus villemoes 3 0.14% 1 1.56%
jan beulich jan beulich 3 0.14% 1 1.56%
ben dooks ben dooks 3 0.14% 1 1.56%
ralf baechle ralf baechle 1 0.05% 1 1.56%
robert p. j. day robert p. j. day 1 0.05% 1 1.56%
suresh siddha suresh siddha 1 0.05% 1 1.56%
arnd bergmann arnd bergmann 1 0.05% 1 1.56%
Total 2102 100.00% 64 100.00%
Directory: drivers/base

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

Release 4.10 drivers/base/cpu.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

Overall Contributors
