From 5e5f5c8eb1ec0cb340a7a1022a0c0aea569d11e0 Mon Sep 17 00:00:00 2001 From: Christoph Lameter Date: Thu, 14 Feb 2019 21:54:49 -0600 Subject: [PATCH 2/4] StarlingX: Kernel Threads Compute CPU Affinity This is a kernel enhancement to configure the cpu affinity of kernel threads via kernel boot option kthread_cpus=. The compute kickstart file and compute-huge.sh scripts will update grub with the new option. With kthread_cpus specified, the cpumask is immediately applied upon thread launch. This does not affect kernel threads that specify cpu and node. Note: this is based off of Christoph Lameter's patch at https://lwn.net/Articles/565932/ with the only difference being the kernel parameter changed from kthread to kthread_cpus. Signed-off-by: Christoph Lameter Signed-off-by: Chris Friesen [VT: The existing "isolcpus" kernel bootarg, cgroup/cpuset, and taskset might provide the some way to have cpu isolation. However none of them satisfies the requirements. Replacing spaces with tabs. Combine two calls of set_cpus_allowed_ptr() in kernel_init_freeable() in init/main.c into one. Performed tests] Signed-off-by: Vu Tran Signed-off-by: Jim Somerville Signed-off-by: Abraham Arce Signed-off-by: Abraham Arce --- Documentation/admin-guide/kernel-parameters.txt | 17 +++++++++++++++++ include/linux/cpumask.h | 3 +++ init/main.c | 2 ++ kernel/cpu.c | 13 +++++++++++++ kernel/kthread.c | 4 ++-- 5 files changed, 37 insertions(+), 2 deletions(-) diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt index 533ff5c..cc174ff 100644 --- a/Documentation/admin-guide/kernel-parameters.txt +++ b/Documentation/admin-guide/kernel-parameters.txt @@ -1913,6 +1913,23 @@ Built with CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF=y, the default is off. + kmemcheck= [X86] Boot-time kmemcheck enable/disable/one-shot mode + Valid arguments: 0, 1, 2 + kmemcheck=0 (disabled) + kmemcheck=1 (enabled) + kmemcheck=2 (one-shot mode) + Default: 2 (one-shot mode) + + kthread_cpus= [KNL, SMP] Only run kernel threads on the specified + list of processors. The kernel will start threads + on the indicated processors only (unless there + are specific reasons to run a thread with + different affinities). This can be used to make + init start on certain processors and also to + control where kmod and other user space threads + are being spawned. Allows to keep kernel threads + away from certain cores unless absoluteluy necessary. + kvm.ignore_msrs=[KVM] Ignore guest accesses to unhandled MSRs. Default is 0 (don't ignore, but inject #GP) diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h index bf53d89..1b891bd 100644 --- a/include/linux/cpumask.h +++ b/include/linux/cpumask.h @@ -54,6 +54,7 @@ extern unsigned int nr_cpu_ids; * cpu_present_mask - has bit 'cpu' set iff cpu is populated * cpu_online_mask - has bit 'cpu' set iff cpu available to scheduler * cpu_active_mask - has bit 'cpu' set iff cpu available to migration + * cpu_kthread_mask - has bit 'cpu' set iff general kernel threads allowed * * If !CONFIG_HOTPLUG_CPU, present == possible, and active == online. * @@ -90,10 +91,12 @@ extern struct cpumask __cpu_possible_mask; extern struct cpumask __cpu_online_mask; extern struct cpumask __cpu_present_mask; extern struct cpumask __cpu_active_mask; +extern struct cpumask __cpu_kthread_mask; #define cpu_possible_mask ((const struct cpumask *)&__cpu_possible_mask) #define cpu_online_mask ((const struct cpumask *)&__cpu_online_mask) #define cpu_present_mask ((const struct cpumask *)&__cpu_present_mask) #define cpu_active_mask ((const struct cpumask *)&__cpu_active_mask) +#define cpu_kthread_mask ((const struct cpumask *)&__cpu_kthread_mask) #if NR_CPUS > 1 #define num_online_cpus() cpumask_weight(cpu_online_mask) diff --git a/init/main.c b/init/main.c index 5e13c54..a2e1c2b 100644 --- a/init/main.c +++ b/init/main.c @@ -1134,6 +1134,8 @@ static noinline void __init kernel_init_freeable(void) do_basic_setup(); + set_cpus_allowed_ptr(current, cpu_kthread_mask); + /* Open the /dev/console on the rootfs, this should never fail */ if (ksys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) pr_err("Warning: unable to open an initial console.\n"); diff --git a/kernel/cpu.c b/kernel/cpu.c index 2f8f338..aad909f 100644 --- a/kernel/cpu.c +++ b/kernel/cpu.c @@ -1957,6 +1957,9 @@ EXPORT_SYMBOL_GPL(cpu_bit_bitmap); const DECLARE_BITMAP(cpu_all_bits, NR_CPUS) = CPU_BITS_ALL; EXPORT_SYMBOL(cpu_all_bits); +const DECLARE_BITMAP(cpu_kthread_bits, CONFIG_NR_CPUS) = CPU_BITS_ALL; +EXPORT_SYMBOL(cpu_kthread_bits); + #ifdef CONFIG_INIT_ALL_POSSIBLE struct cpumask __cpu_possible_mask __read_mostly = {CPU_BITS_ALL}; @@ -1974,6 +1977,16 @@ EXPORT_SYMBOL(__cpu_present_mask); struct cpumask __cpu_active_mask __read_mostly; EXPORT_SYMBOL(__cpu_active_mask); +struct cpumask __cpu_kthread_mask __read_mostly; +EXPORT_SYMBOL(__cpu_kthread_mask); + +static int __init kthread_setup(char *str) +{ + cpulist_parse(str, (struct cpumask *)&cpu_kthread_bits); + return 1; +} +__setup("kthread=", kthread_setup); + void init_cpu_present(const struct cpumask *src) { cpumask_copy(&__cpu_present_mask, src); diff --git a/kernel/kthread.c b/kernel/kthread.c index 486dedb..697ec70 100644 --- a/kernel/kthread.c +++ b/kernel/kthread.c @@ -338,7 +338,7 @@ struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data), * The kernel thread should not inherit these properties. */ sched_setscheduler_nocheck(task, SCHED_NORMAL, ¶m); - set_cpus_allowed_ptr(task, cpu_all_mask); + set_cpus_allowed_ptr(task, cpu_kthread_mask); } kfree(create); return task; @@ -561,7 +561,7 @@ int kthreadd(void *unused) /* Setup a clean context for our children to inherit. */ set_task_comm(tsk, "kthreadd"); ignore_signals(tsk); - set_cpus_allowed_ptr(tsk, cpu_all_mask); + set_cpus_allowed_ptr(tsk, cpu_kthread_mask); set_mems_allowed(node_states[N_MEMORY]); current->flags |= PF_NOFREEZE; -- 2.7.4