2554 lines · 60.8 KB · C
RawDownload
 */void __cpuhp_remove_state_cpuslocked(enum cpuhp_state state, bool invoke){	struct cpuhp_step *sp = cpuhp_get_step(state);	int cpu; 	BUG_ON(cpuhp_cb_check(state)); 	lockdep_assert_cpus_held(); 	mutex_lock(&cpuhp_state_mutex);	if (sp->multi_instance) {		WARN(!hlist_empty(&sp->list),		     "Error: Removing state %d which has instances left.\n",		     state);		goto remove;	} 	if (!invoke || !cpuhp_get_teardown_cb(state))		goto remove; 	/*	 * Call the teardown callback for each present cpu depending	 * on the hotplug state of the cpu. This function is not	 * allowed to fail currently!	 */	for_each_present_cpu(cpu) {		struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);		int cpustate = st->state; 		if (cpustate >= state)			cpuhp_issue_call(cpu, state, false, NULL);	}remove:	cpuhp_store_callbacks(state, NULL, NULL, NULL, false);	mutex_unlock(&cpuhp_state_mutex);}EXPORT_SYMBOL(__cpuhp_remove_state_cpuslocked); void __cpuhp_remove_state(enum cpuhp_state state, bool invoke){	cpus_read_lock();	__cpuhp_remove_state_cpuslocked(state, invoke);	cpus_read_unlock();}EXPORT_SYMBOL(__cpuhp_remove_state); #ifdef CONFIG_HOTPLUG_SMTstatic void cpuhp_offline_cpu_device(unsigned int cpu){	struct device *dev = get_cpu_device(cpu); 	dev->offline = true;	/* Tell user space about the state change */	kobject_uevent(&dev->kobj, KOBJ_OFFLINE);} static void cpuhp_online_cpu_device(unsigned int cpu){	struct device *dev = get_cpu_device(cpu); 	dev->offline = false;	/* Tell user space about the state change */	kobject_uevent(&dev->kobj, KOBJ_ONLINE);} int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval){	int cpu, ret = 0; 	cpu_maps_update_begin();	for_each_online_cpu(cpu) {		if (topology_is_primary_thread(cpu))			continue;		ret = cpu_down_maps_locked(cpu, CPUHP_OFFLINE);		if (ret)			break;		/*		 * As this needs to hold the cpu maps lock it's impossible		 * to call device_offline() because that ends up calling		 * cpu_down() which takes cpu maps lock. cpu maps lock		 * needs to be held as this might race against in kernel		 * abusers of the hotplug machinery (thermal management).		 *		 * So nothing would update device:offline state. That would		 * leave the sysfs entry stale and prevent onlining after		 * smt control has been changed to 'off' again. This is		 * called under the sysfs hotplug lock, so it is properly		 * serialized against the regular offline usage.		 */		cpuhp_offline_cpu_device(cpu);	}	if (!ret)		cpu_smt_control = ctrlval;	cpu_maps_update_done();	return ret;} int cpuhp_smt_enable(void){	int cpu, ret = 0; 	cpu_maps_update_begin();	cpu_smt_control = CPU_SMT_ENABLED;	for_each_present_cpu(cpu) {		/* Skip online CPUs and CPUs on offline nodes */		if (cpu_online(cpu) || !node_online(cpu_to_node(cpu)))			continue;		ret = _cpu_up(cpu, 0, CPUHP_ONLINE);		if (ret)			break;		/* See comment in cpuhp_smt_disable() */		cpuhp_online_cpu_device(cpu);	}	cpu_maps_update_done();	return ret;}#endif #if defined(CONFIG_SYSFS) && defined(CONFIG_HOTPLUG_CPU)static ssize_t show_cpuhp_state(struct device *dev,				struct device_attribute *attr, char *buf){	struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id); 	return sprintf(buf, "%d\n", st->state);}static DEVICE_ATTR(state, 0444, show_cpuhp_state, NULL); static ssize_t write_cpuhp_target(struct device *dev,				  struct device_attribute *attr,				  const char *buf, size_t count){	struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);	struct cpuhp_step *sp;	int target, ret; 	ret = kstrtoint(buf, 10, &target);	if (ret)		return ret; #ifdef CONFIG_CPU_HOTPLUG_STATE_CONTROL	if (target < CPUHP_OFFLINE || target > CPUHP_ONLINE)		return -EINVAL;#else	if (target != CPUHP_OFFLINE && target != CPUHP_ONLINE)		return -EINVAL;#endif 	ret = lock_device_hotplug_sysfs();	if (ret)		return ret; 	mutex_lock(&cpuhp_state_mutex);	sp = cpuhp_get_step(target);	ret = !sp->name || sp->cant_stop ? -EINVAL : 0;	mutex_unlock(&cpuhp_state_mutex);	if (ret)		goto out; 	if (st->state < target)		ret = cpu_up(dev->id, target);	else		ret = cpu_down(dev->id, target);out:	unlock_device_hotplug();	return ret ? ret : count;} static ssize_t show_cpuhp_target(struct device *dev,				 struct device_attribute *attr, char *buf){	struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id); 	return sprintf(buf, "%d\n", st->target);}static DEVICE_ATTR(target, 0644, show_cpuhp_target, write_cpuhp_target);  static ssize_t write_cpuhp_fail(struct device *dev,				struct device_attribute *attr,				const char *buf, size_t count){	struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);	struct cpuhp_step *sp;	int fail, ret; 	ret = kstrtoint(buf, 10, &fail);	if (ret)		return ret; 	if (fail < CPUHP_OFFLINE || fail > CPUHP_ONLINE)		return -EINVAL; 	/*	 * Cannot fail STARTING/DYING callbacks.	 */	if (cpuhp_is_atomic_state(fail))		return -EINVAL; 	/*	 * Cannot fail anything that doesn't have callbacks.	 */	mutex_lock(&cpuhp_state_mutex);	sp = cpuhp_get_step(fail);	if (!sp->startup.single && !sp->teardown.single)		ret = -EINVAL;	mutex_unlock(&cpuhp_state_mutex);	if (ret)		return ret; 	st->fail = fail; 	return count;} static ssize_t show_cpuhp_fail(struct device *dev,			       struct device_attribute *attr, char *buf){	struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id); 	return sprintf(buf, "%d\n", st->fail);} static DEVICE_ATTR(fail, 0644, show_cpuhp_fail, write_cpuhp_fail); static struct attribute *cpuhp_cpu_attrs[] = {	&dev_attr_state.attr,	&dev_attr_target.attr,	&dev_attr_fail.attr,	NULL}; static const struct attribute_group cpuhp_cpu_attr_group = {	.attrs = cpuhp_cpu_attrs,	.name = "hotplug",	NULL}; static ssize_t show_cpuhp_states(struct device *dev,				 struct device_attribute *attr, char *buf){	ssize_t cur, res = 0;	int i; 	mutex_lock(&cpuhp_state_mutex);	for (i = CPUHP_OFFLINE; i <= CPUHP_ONLINE; i++) {		struct cpuhp_step *sp = cpuhp_get_step(i); 		if (sp->name) {			cur = sprintf(buf, "%3d: %s\n", i, sp->name);			buf += cur;			res += cur;		}	}	mutex_unlock(&cpuhp_state_mutex);	return res;}static DEVICE_ATTR(states, 0444, show_cpuhp_states, NULL); static struct attribute *cpuhp_cpu_root_attrs[] = {	&dev_attr_states.attr,	NULL}; static const struct attribute_group cpuhp_cpu_root_attr_group = {	.attrs = cpuhp_cpu_root_attrs,	.name = "hotplug",	NULL}; #ifdef CONFIG_HOTPLUG_SMT static ssize_t__store_smt_control(struct device *dev, struct device_attribute *attr,		    const char *buf, size_t count){	int ctrlval, ret; 	if (sysfs_streq(buf, "on"))		ctrlval = CPU_SMT_ENABLED;	else if (sysfs_streq(buf, "off"))		ctrlval = CPU_SMT_DISABLED;	else if (sysfs_streq(buf, "forceoff"))		ctrlval = CPU_SMT_FORCE_DISABLED;	else		return -EINVAL; 	if (cpu_smt_control == CPU_SMT_FORCE_DISABLED)		return -EPERM; 	if (cpu_smt_control == CPU_SMT_NOT_SUPPORTED)		return -ENODEV; 	ret = lock_device_hotplug_sysfs();	if (ret)		return ret; 	if (ctrlval != cpu_smt_control) {		switch (ctrlval) {		case CPU_SMT_ENABLED:			ret = cpuhp_smt_enable();			break;		case CPU_SMT_DISABLED:		case CPU_SMT_FORCE_DISABLED:			ret = cpuhp_smt_disable(ctrlval);			break;		}	} 	unlock_device_hotplug();	return ret ? ret : count;} #else /* !CONFIG_HOTPLUG_SMT */static ssize_t__store_smt_control(struct device *dev, struct device_attribute *attr,		    const char *buf, size_t count){	return -ENODEV;}#endif /* CONFIG_HOTPLUG_SMT */ static const char *smt_states[] = {	[CPU_SMT_ENABLED]		= "on",	[CPU_SMT_DISABLED]		= "off",	[CPU_SMT_FORCE_DISABLED]	= "forceoff",	[CPU_SMT_NOT_SUPPORTED]		= "notsupported",	[CPU_SMT_NOT_IMPLEMENTED]	= "notimplemented",}; static ssize_tshow_smt_control(struct device *dev, struct device_attribute *attr, char *buf){	const char *state = smt_states[cpu_smt_control]; 	return snprintf(buf, PAGE_SIZE - 2, "%s\n", state);} static ssize_tstore_smt_control(struct device *dev, struct device_attribute *attr,		  const char *buf, size_t count){	return __store_smt_control(dev, attr, buf, count);}static DEVICE_ATTR(control, 0644, show_smt_control, store_smt_control); static ssize_tshow_smt_active(struct device *dev, struct device_attribute *attr, char *buf){	return snprintf(buf, PAGE_SIZE - 2, "%d\n", sched_smt_active());}static DEVICE_ATTR(active, 0444, show_smt_active, NULL); static struct attribute *cpuhp_smt_attrs[] = {	&dev_attr_control.attr,	&dev_attr_active.attr,	NULL}; static const struct attribute_group cpuhp_smt_attr_group = {	.attrs = cpuhp_smt_attrs,	.name = "smt",	NULL}; static int __init cpu_smt_sysfs_init(void){	return sysfs_create_group(&cpu_subsys.dev_root->kobj,				  &cpuhp_smt_attr_group);} static int __init cpuhp_sysfs_init(void){	int cpu, ret; 	ret = cpu_smt_sysfs_init();	if (ret)		return ret; 	ret = sysfs_create_group(&cpu_subsys.dev_root->kobj,				 &cpuhp_cpu_root_attr_group);	if (ret)		return ret; 	for_each_possible_cpu(cpu) {		struct device *dev = get_cpu_device(cpu); 		if (!dev)			continue;		ret = sysfs_create_group(&dev->kobj, &cpuhp_cpu_attr_group);		if (ret)			return ret;	}	return 0;}device_initcall(cpuhp_sysfs_init);#endif /* CONFIG_SYSFS && CONFIG_HOTPLUG_CPU */ /* * cpu_bit_bitmap[] is a special, "compressed" data structure that * represents all NR_CPUS bits binary values of 1<<nr. * * It is used by cpumask_of() to get a constant address to a CPU * mask value that has a single bit set only. */ /* cpu_bit_bitmap[0] is empty - so we can back into it */#define MASK_DECLARE_1(x)	[x+1][0] = (1UL << (x))#define MASK_DECLARE_2(x)	MASK_DECLARE_1(x), MASK_DECLARE_1(x+1)#define MASK_DECLARE_4(x)	MASK_DECLARE_2(x), MASK_DECLARE_2(x+2)#define MASK_DECLARE_8(x)	MASK_DECLARE_4(x), MASK_DECLARE_4(x+4) const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)] = { 	MASK_DECLARE_8(0),	MASK_DECLARE_8(8),	MASK_DECLARE_8(16),	MASK_DECLARE_8(24),#if BITS_PER_LONG > 32	MASK_DECLARE_8(32),	MASK_DECLARE_8(40),	MASK_DECLARE_8(48),	MASK_DECLARE_8(56),#endif};EXPORT_SYMBOL_GPL(cpu_bit_bitmap); const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL;EXPORT_SYMBOL(cpu_all_bits); #ifdef CONFIG_INIT_ALL_POSSIBLEstruct cpumask __cpu_possible_mask __read_mostly	= {CPU_BITS_ALL};#elsestruct cpumask __cpu_possible_mask __read_mostly;#endifEXPORT_SYMBOL(__cpu_possible_mask); struct cpumask __cpu_online_mask __read_mostly;EXPORT_SYMBOL(__cpu_online_mask); struct cpumask __cpu_present_mask __read_mostly;EXPORT_SYMBOL(__cpu_present_mask); struct cpumask __cpu_active_mask __read_mostly;EXPORT_SYMBOL(__cpu_active_mask); atomic_t __num_online_cpus __read_mostly;EXPORT_SYMBOL(__num_online_cpus); void init_cpu_present(const struct cpumask *src){	cpumask_copy(&__cpu_present_mask, src);} void init_cpu_possible(const struct cpumask *src){	cpumask_copy(&__cpu_possible_mask, src);} void init_cpu_online(const struct cpumask *src){	cpumask_copy(&__cpu_online_mask, src);} void set_cpu_online(unsigned int cpu, bool online){	/*	 * atomic_inc/dec() is required to handle the horrid abuse of this	 * function by the reboot and kexec code which invoke it from	 * IPI/NMI broadcasts when shutting down CPUs. Invocation from	 * regular CPU hotplug is properly serialized.	 *	 * Note, that the fact that __num_online_cpus is of type atomic_t	 * does not protect readers which are not serialized against	 * concurrent hotplug operations.	 */	if (online) {		if (!cpumask_test_and_set_cpu(cpu, &__cpu_online_mask))			atomic_inc(&__num_online_cpus);	} else {		if (cpumask_test_and_clear_cpu(cpu, &__cpu_online_mask))			atomic_dec(&__num_online_cpus);	}} /* * Activate the first processor. */void __init boot_cpu_init(void){	int cpu = smp_processor_id(); 	/* Mark the boot cpu "present", "online" etc for SMP and UP case */	set_cpu_online(cpu, true);	set_cpu_active(cpu, true);	set_cpu_present(cpu, true);	set_cpu_possible(cpu, true); #ifdef CONFIG_SMP	__boot_cpu_id = cpu;#endif}

Lines 2001–2500 of 2554. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t