Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3866e845 authored by Steven Rostedt (Red Hat)'s avatar Steven Rostedt (Red Hat) Committed by Ingo Molnar
Browse files

sched/debug: Move sched_domain_sysctl to debug.c 



The sched_domain_sysctl setup is only enabled when SCHED_DEBUG is
configured. As debug.c is only compiled when SCHED_DEBUG is configured as
well, move the setup of sched_domain_sysctl into that file.

Note, the (un)register_sched_domain_sysctl() functions had to be changed
from static to allow access to them from core.c.

Signed-off-by: default avatarSteven Rostedt <rostedt@goodmis.org>
Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Clark Williams <williams@redhat.com>
Cc: Juri Lelli <juri.lelli@gmail.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lkml.kernel.org/r/20160222212825.599278093@goodmis.org


Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent d6ca41d7

kernel/sched/core.c

+0 −178
Original line number Diff line number Diff line
@@ -70,7 +70,6 @@ 
#include <linux/ftrace.h>

#include <linux/slab.h>

#include <linux/init_task.h>

#include <linux/binfmts.h>

#include <linux/context_tracking.h>

#include <linux/compiler.h>
@@ -5342,183 +5341,6 @@ static void migrate_tasks(struct rq *dead_rq) 
}

#endif /* CONFIG_HOTPLUG_CPU */



#if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)



static struct ctl_table sd_ctl_dir[] = {

	{

		.procname	= "sched_domain",

		.mode		= 0555,

	},

	{}

};



static struct ctl_table sd_ctl_root[] = {

	{

		.procname	= "kernel",

		.mode		= 0555,

		.child		= sd_ctl_dir,

	},

	{}

};



static struct ctl_table *sd_alloc_ctl_entry(int n)

{

	struct ctl_table *entry =

		kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);



	return entry;

}



static void sd_free_ctl_entry(struct ctl_table **tablep)

{

	struct ctl_table *entry;



	/*

	 * In the intermediate directories, both the child directory and

	 * procname are dynamically allocated and could fail but the mode

	 * will always be set. In the lowest directory the names are

	 * static strings and all have proc handlers.

	 */

	for (entry = *tablep; entry->mode; entry++) {

		if (entry->child)

			sd_free_ctl_entry(&entry->child);

		if (entry->proc_handler == NULL)

			kfree(entry->procname);

	}



	kfree(*tablep);

	*tablep = NULL;

}



static int min_load_idx = 0;

static int max_load_idx = CPU_LOAD_IDX_MAX-1;



static void

set_table_entry(struct ctl_table *entry,

		const char *procname, void *data, int maxlen,

		umode_t mode, proc_handler *proc_handler,

		bool load_idx)

{

	entry->procname = procname;

	entry->data = data;

	entry->maxlen = maxlen;

	entry->mode = mode;

	entry->proc_handler = proc_handler;



	if (load_idx) {

		entry->extra1 = &min_load_idx;

		entry->extra2 = &max_load_idx;

	}

}



static struct ctl_table *

sd_alloc_ctl_domain_table(struct sched_domain *sd)

{

	struct ctl_table *table = sd_alloc_ctl_entry(14);



	if (table == NULL)

		return NULL;



	set_table_entry(&table[0], "min_interval", &sd->min_interval,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[1], "max_interval", &sd->max_interval,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[2], "busy_idx", &sd->busy_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[3], "idle_idx", &sd->idle_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[5], "wake_idx", &sd->wake_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[7], "busy_factor", &sd->busy_factor,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[9], "cache_nice_tries",

		&sd->cache_nice_tries,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[10], "flags", &sd->flags,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[11], "max_newidle_lb_cost",

		&sd->max_newidle_lb_cost,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[12], "name", sd->name,

		CORENAME_MAX_SIZE, 0444, proc_dostring, false);

	/* &table[13] is terminator */



	return table;

}



static struct ctl_table *sd_alloc_ctl_cpu_table(int cpu)

{

	struct ctl_table *entry, *table;

	struct sched_domain *sd;

	int domain_num = 0, i;

	char buf[32];



	for_each_domain(cpu, sd)

		domain_num++;

	entry = table = sd_alloc_ctl_entry(domain_num + 1);

	if (table == NULL)

		return NULL;



	i = 0;

	for_each_domain(cpu, sd) {

		snprintf(buf, 32, "domain%d", i);

		entry->procname = kstrdup(buf, GFP_KERNEL);

		entry->mode = 0555;

		entry->child = sd_alloc_ctl_domain_table(sd);

		entry++;

		i++;

	}

	return table;

}



static struct ctl_table_header *sd_sysctl_header;

static void register_sched_domain_sysctl(void)

{

	int i, cpu_num = num_possible_cpus();

	struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);

	char buf[32];



	WARN_ON(sd_ctl_dir[0].child);

	sd_ctl_dir[0].child = entry;



	if (entry == NULL)

		return;



	for_each_possible_cpu(i) {

		snprintf(buf, 32, "cpu%d", i);

		entry->procname = kstrdup(buf, GFP_KERNEL);

		entry->mode = 0555;

		entry->child = sd_alloc_ctl_cpu_table(i);

		entry++;

	}



	WARN_ON(sd_sysctl_header);

	sd_sysctl_header = register_sysctl_table(sd_ctl_root);

}



/* may be called multiple times per register */

static void unregister_sched_domain_sysctl(void)

{

	unregister_sysctl_table(sd_sysctl_header);

	sd_sysctl_header = NULL;

	if (sd_ctl_dir[0].child)

		sd_free_ctl_entry(&sd_ctl_dir[0].child);

}

#else

static void register_sched_domain_sysctl(void)

{

}

static void unregister_sched_domain_sysctl(void)

{

}

#endif /* CONFIG_SCHED_DEBUG && CONFIG_SYSCTL */



static void set_rq_online(struct rq *rq)

{

	if (!rq->online) {

kernel/sched/debug.c

+173 −0
Original line number Diff line number Diff line
@@ -189,6 +189,179 @@ static __init int sched_init_debug(void) 
}

late_initcall(sched_init_debug);



#ifdef CONFIG_SMP



#ifdef CONFIG_SYSCTL



static struct ctl_table sd_ctl_dir[] = {

	{

		.procname	= "sched_domain",

		.mode		= 0555,

	},

	{}

};



static struct ctl_table sd_ctl_root[] = {

	{

		.procname	= "kernel",

		.mode		= 0555,

		.child		= sd_ctl_dir,

	},

	{}

};



static struct ctl_table *sd_alloc_ctl_entry(int n)

{

	struct ctl_table *entry =

		kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);



	return entry;

}



static void sd_free_ctl_entry(struct ctl_table **tablep)

{

	struct ctl_table *entry;



	/*

	 * In the intermediate directories, both the child directory and

	 * procname are dynamically allocated and could fail but the mode

	 * will always be set. In the lowest directory the names are

	 * static strings and all have proc handlers.

	 */

	for (entry = *tablep; entry->mode; entry++) {

		if (entry->child)

			sd_free_ctl_entry(&entry->child);

		if (entry->proc_handler == NULL)

			kfree(entry->procname);

	}



	kfree(*tablep);

	*tablep = NULL;

}



static int min_load_idx = 0;

static int max_load_idx = CPU_LOAD_IDX_MAX-1;



static void

set_table_entry(struct ctl_table *entry,

		const char *procname, void *data, int maxlen,

		umode_t mode, proc_handler *proc_handler,

		bool load_idx)

{

	entry->procname = procname;

	entry->data = data;

	entry->maxlen = maxlen;

	entry->mode = mode;

	entry->proc_handler = proc_handler;



	if (load_idx) {

		entry->extra1 = &min_load_idx;

		entry->extra2 = &max_load_idx;

	}

}



static struct ctl_table *

sd_alloc_ctl_domain_table(struct sched_domain *sd)

{

	struct ctl_table *table = sd_alloc_ctl_entry(14);



	if (table == NULL)

		return NULL;



	set_table_entry(&table[0], "min_interval", &sd->min_interval,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[1], "max_interval", &sd->max_interval,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[2], "busy_idx", &sd->busy_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[3], "idle_idx", &sd->idle_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[5], "wake_idx", &sd->wake_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,

		sizeof(int), 0644, proc_dointvec_minmax, true);

	set_table_entry(&table[7], "busy_factor", &sd->busy_factor,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[9], "cache_nice_tries",

		&sd->cache_nice_tries,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[10], "flags", &sd->flags,

		sizeof(int), 0644, proc_dointvec_minmax, false);

	set_table_entry(&table[11], "max_newidle_lb_cost",

		&sd->max_newidle_lb_cost,

		sizeof(long), 0644, proc_doulongvec_minmax, false);

	set_table_entry(&table[12], "name", sd->name,

		CORENAME_MAX_SIZE, 0444, proc_dostring, false);

	/* &table[13] is terminator */



	return table;

}



static struct ctl_table *sd_alloc_ctl_cpu_table(int cpu)

{

	struct ctl_table *entry, *table;

	struct sched_domain *sd;

	int domain_num = 0, i;

	char buf[32];



	for_each_domain(cpu, sd)

		domain_num++;

	entry = table = sd_alloc_ctl_entry(domain_num + 1);

	if (table == NULL)

		return NULL;



	i = 0;

	for_each_domain(cpu, sd) {

		snprintf(buf, 32, "domain%d", i);

		entry->procname = kstrdup(buf, GFP_KERNEL);

		entry->mode = 0555;

		entry->child = sd_alloc_ctl_domain_table(sd);

		entry++;

		i++;

	}

	return table;

}



static struct ctl_table_header *sd_sysctl_header;

void register_sched_domain_sysctl(void)

{

	int i, cpu_num = num_possible_cpus();

	struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);

	char buf[32];



	WARN_ON(sd_ctl_dir[0].child);

	sd_ctl_dir[0].child = entry;



	if (entry == NULL)

		return;



	for_each_possible_cpu(i) {

		snprintf(buf, 32, "cpu%d", i);

		entry->procname = kstrdup(buf, GFP_KERNEL);

		entry->mode = 0555;

		entry->child = sd_alloc_ctl_cpu_table(i);

		entry++;

	}



	WARN_ON(sd_sysctl_header);

	sd_sysctl_header = register_sysctl_table(sd_ctl_root);

}



/* may be called multiple times per register */

void unregister_sched_domain_sysctl(void)

{

	unregister_sysctl_table(sd_sysctl_header);

	sd_sysctl_header = NULL;

	if (sd_ctl_dir[0].child)

		sd_free_ctl_entry(&sd_ctl_dir[0].child);

}

#endif /* CONFIG_SYSCTL */

#endif /* CONFIG_SMP */



#ifdef CONFIG_FAIR_GROUP_SCHED

static void print_cfs_group_stats(struct seq_file *m, int cpu, struct task_group *tg)

{

kernel/sched/sched.h

+13 −0
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 
#include <linux/sched/sysctl.h>

#include <linux/sched/rt.h>

#include <linux/sched/deadline.h>

#include <linux/binfmts.h>

#include <linux/mutex.h>

#include <linux/spinlock.h>

#include <linux/stop_machine.h>
@@ -908,6 +909,18 @@ static inline unsigned int group_first_cpu(struct sched_group *group) 


extern int group_balance_cpu(struct sched_group *sg);



#if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)

void register_sched_domain_sysctl(void);

void unregister_sched_domain_sysctl(void);

#else

static inline void register_sched_domain_sysctl(void)

{

}

static inline void unregister_sched_domain_sysctl(void)

{

}

#endif



#else



static inline void sched_ttwu_pending(void) { }