Introduce SMT level and add PowerPC support
Subsystems (6)
v2 cover Introduce SMT level and add PowerPC support
I'm taking over the series Michael sent previously [1] which is smartly reviewing the initial series I sent [2]. This series is addressing the comments sent by Thomas and me on the Michael's one.
Here is a short introduction to the issue this series is addressing:
When a new CPU is added, the kernel is activating all its threads. This leads to weird, but functional, result when adding CPU on a SMT 4 system for instance.
Here the newly added CPU 1 has 8 threads while the other one has 4 threads active (system has been booted with the 'smt-enabled=4' kernel option):
ltcden3-lp12:~ # ppc64_cpu --info
Core 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12* 13* 14* 15*
This mixed SMT level may confused end users and/or some applications.
There is no SMT level recorded in the kernel (common code), neither in user space, as far as I know. Such a level is helpful when adding new CPU or when optimizing the energy efficiency (when reactivating CPUs).
When SMP and HOTPLUG_SMT are defined, this series is adding a new SMT level (cpu_smt_num_threads) and few callbacks allowing the architecture code to fine control this value, setting a max and a "at boot" level, and controling whether a thread should be onlined or not.
v2:
As Thomas suggested,
Reword some commit's description
Remove topology_smt_supported()
Remove topology_smt_threads_supported()
Introduce CONFIG_SMT_NUM_THREADS_DYNAMIC
Remove switch() in __store_smt_control()
Update kernel-parameters.txt
[1] https://lore.kernel.org/linuxppc-dev/[email protected]/
[2] https://lore.kernel.org/linuxppc-dev/[email protected]/
Laurent Dufour (1):
cpu/SMT: Remove topology_smt_supported()
Michael Ellerman (8):
cpu/SMT: Move SMT prototypes into cpu_smt.h
cpu/SMT: Move smt/control simple exit cases earlier cpu/SMT: Store the current/max number of threads cpu/SMT: Create topology_smt_thread_allowed()
cpu/SMT: Allow enabling partial SMT states via sysfs powerpc/pseries: Initialise CPU hotplug callbacks earlier
powerpc: Add HOTPLUG_SMT support
powerpc/pseries: Honour current SMT state when DLPAR onlining CPUs
.../ABI/testing/sysfs-devices-system-cpu | 1 + .../admin-guide/kernel-parameters.txt | 4 +- arch/Kconfig | 3 + arch/powerpc/Kconfig | 2 + arch/powerpc/include/asm/topology.h | 15 +++ arch/powerpc/kernel/smp.c | 8 +- arch/powerpc/platforms/pseries/hotplug-cpu.c | 30 +++-- arch/powerpc/platforms/pseries/pseries.h | 2 + arch/powerpc/platforms/pseries/setup.c | 2 + arch/x86/include/asm/topology.h | 4 +- arch/x86/kernel/cpu/bugs.c | 3 +- arch/x86/kernel/smpboot.c | 8 -- include/linux/cpu.h | 25 +--- include/linux/cpu_smt.h | 33 +++++ kernel/cpu.c | 116 ++++++++++++++---- 15 files changed, 185 insertions(+), 71 deletions(-) create mode 100644 include/linux/cpu_smt.h
Signature · 1 line
2.41.0
PATCH v2 1/9 cpu/SMT: Move SMT prototypes into cpu_smt.h
From: Michael Ellerman <[email protected]>
In order to export the cpuhp_smt_control enum as part of the interface between generic and architecture code, the architecture code needs to include asm/topology.h.
But that leads to circular header dependencies. So split the enum and related declarations into a separate header.
--- arch/x86/include/asm/topology.h | 2 ++ include/linux/cpu.h | 25 +------------------------ include/linux/cpu_smt.h | 29 +++++++++++++++++++++++++++++ kernel/cpu.c | 1 + 4 files changed, 33 insertions(+), 24 deletions(-) create mode 100644 include/linux/cpu_smt.h
arch/x86/include/asm/topology.h +2 -0
@@ -136,6 +136,8 @@ static inline int topology_max_smt_threads(void)return __max_smt_threads; } +#include <linux/cpu_smt.h> +int topology_update_package_map (unsigned int apicid,unsigned int cpu);int topology_update_die_map (unsigned int dieid,unsigned int cpu);int topology_phys_to_logical_pkg (unsigned int pkg);
include/linux/cpu.h +1 -24
@@ -18,6 +18,7 @@#include <linux/compiler.h> #include <linux/cpumask.h> #include <linux/cpuhotplug.h> +#include <linux/cpu_smt.h> struct device ;struct device_node ;
@@ -202,30 +203,6 @@ void cpuhp_report_idle_dead(void);static inline void cpuhp_report_idle_dead (void ) { }#endif /* #ifdef CONFIG_HOTPLUG_CPU */ -enum cpuhp_smt_control { -CPU_SMT_ENABLED , -CPU_SMT_DISABLED , -CPU_SMT_FORCE_DISABLED , -CPU_SMT_NOT_SUPPORTED , -CPU_SMT_NOT_IMPLEMENTED , -}; - -#if defined(CONFIG_SMP ) && defined(CONFIG_HOTPLUG_SMT ) -extern enum cpuhp_smt_control cpu_smt_control; -extern void cpu_smt_disable (bool force); -extern void cpu_smt_check_topology (void ); -extern bool cpu_smt_possible (void ); -extern int cpuhp_smt_enable (void ); -extern int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval); -#else -# define cpu_smt_control (CPU_SMT_NOT_IMPLEMENTED) -static inline void cpu_smt_disable (bool force) { } -static inline void cpu_smt_check_topology (void ) { } -static inline bool cpu_smt_possible (void ) {return false; } -static inline int cpuhp_smt_enable (void ) {return 0 ; } -static inline int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval) {return 0 ; } -#endif -extern bool cpu_mitigations_off (void );extern bool cpu_mitigations_auto_nosmt (void );
include/linux/cpu_smt.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_CPU_SMT_H_ +#define _LINUX_CPU_SMT_H_ + +enum cpuhp_smt_control { +CPU_SMT_ENABLED , +CPU_SMT_DISABLED , +CPU_SMT_FORCE_DISABLED , +CPU_SMT_NOT_SUPPORTED , +CPU_SMT_NOT_IMPLEMENTED , +}; + +#if defined(CONFIG_SMP ) && defined(CONFIG_HOTPLUG_SMT ) +extern enum cpuhp_smt_control cpu_smt_control; +extern void cpu_smt_disable (bool force); +extern void cpu_smt_check_topology (void ); +extern bool cpu_smt_possible (void ); +extern int cpuhp_smt_enable (void ); +extern int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval); +#else +# define cpu_smt_control (CPU_SMT_NOT_IMPLEMENTED) +static inline void cpu_smt_disable (bool force) { } +static inline void cpu_smt_check_topology (void ) { } +static inline bool cpu_smt_possible (void ) {return false; } +static inline int cpuhp_smt_enable (void ) {return 0 ; } +static inline int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval) {return 0 ; } +#endif + +#endif /* _LINUX_CPU_SMT_H_ */
kernel/cpu.c +1 -0
@@ -413,6 +413,7 @@ static void lockdep_release_cpus_lock(void)void __weak arch_smt_update (void ) { }#ifdef CONFIG_HOTPLUG_SMT +enum cpuhp_smt_control cpu_smt_control__read_mostly =CPU_SMT_ENABLED ;void __init cpu_smt_disable (bool force)
Signature · 1 line
2.41.0
PATCH v2 2/9 cpu/SMT: Move smt/control simple exit cases earlier
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Move the simple exit cases, ie. which don't depend on the value written, earlier in the function. That makes it clearer that regardless of the input those states can not be transitioned out of.
That does have a user-visible effect, in that the error returned will now always be EPERM/ENODEV for those states, regardless of the value written. Previously writing an invalid value would return EINVAL even when in those states.
--- kernel/cpu.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
kernel/cpu.c +6 -6
@@ -2482,6 +2482,12 @@ __store_smt_control(struct device *dev, struct device_attribute *attr, {int ctrlval, ret; +if (cpu_smt_control ==CPU_SMT_FORCE_DISABLED ) +return -EPERM ; + +if (cpu_smt_control ==CPU_SMT_NOT_SUPPORTED ) +return -ENODEV ; +if (sysfs_streq (buf,"on" )) ctrlval =CPU_SMT_ENABLED ;else if (sysfs_streq (buf,"off" ))
@@ -2491,12 +2497,6 @@ __store_smt_control(struct device *dev, struct device_attribute *attr,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;
Signature · 1 line
2.41.0
PATCH v2 3/9 cpu/SMT: Store the current/max number of threads
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Some architectures allows partial SMT states at boot time, ie. when not all SMT threads are brought online.
To support that the SMT code needs to know the maximum number of SMT threads, and also the currently configured number.
The architecture code knows the max number of threads, so have the architecture code pass that value to cpu_smt_set_num_threads(). Note that although topology_max_smt_threads() exists, it is not configured early enough to be used here. As architecture, like PowerPC, allows the threads number to be set through the kernel command line, also pass that value.
--- arch/x86/kernel/cpu/bugs.c | 3 ++- include/linux/cpu_smt.h | 8 ++++++-- kernel/cpu.c | 21 ++++++++++++++++++++- 3 files changed, 28 insertions(+), 4 deletions(-)
arch/x86/kernel/cpu/bugs.c +2 -1
@@ -34,6 +34,7 @@#include <asm/hypervisor.h> #include <asm/tlbflush.h> #include <asm/cpu.h> +#include <asm/smp.h> #include "cpu.h"
@@ -133,7 +134,7 @@ void __init check_bugs(void)* identify_boot_cpu() initialized SMT support information, let the * core code know. */ -cpu_smt_check_topology (); +cpu_smt_set_num_threads (smp_num_siblings, smp_num_siblings);if (!IS_ENABLED (CONFIG_SMP )) {pr_info ("CPU: " );
include/linux/cpu_smt.h +6 -2
@@ -12,15 +12,19 @@ enum cpuhp_smt_control {#if defined(CONFIG_SMP ) && defined(CONFIG_HOTPLUG_SMT )extern enum cpuhp_smt_control cpu_smt_control; +extern unsigned int cpu_smt_num_threads;extern void cpu_smt_disable (bool force); -extern void cpu_smt_check_topology (void ); +extern void cpu_smt_set_num_threads (unsigned int num_threads, +unsigned int max_threads);extern bool cpu_smt_possible (void );extern int cpuhp_smt_enable (void );extern int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval);#else # define cpu_smt_control (CPU_SMT_NOT_IMPLEMENTED) +# define cpu_smt_num_threads 1static inline void cpu_smt_disable (bool force) { } -static inline void cpu_smt_check_topology (void ) { } +static inline void cpu_smt_set_num_threads (unsigned int num_threads, +unsigned int max_threads) { }static inline bool cpu_smt_possible (void ) {return false; }static inline int cpuhp_smt_enable (void ) {return 0 ; }static inline int cpuhp_smt_disable (enum cpuhp_smt_control ctrlval) {return 0 ; }
kernel/cpu.c +20 -1
@@ -415,6 +415,8 @@ void __weak arch_smt_update(void) { }#ifdef CONFIG_HOTPLUG_SMT enum cpuhp_smt_control cpu_smt_control__read_mostly =CPU_SMT_ENABLED ; +static unsigned int cpu_smt_max_threads__ro_after_init ; +unsigned int cpu_smt_num_threads__read_mostly =UINT_MAX ;void __init cpu_smt_disable (bool force) {
@@ -428,16 +430,33 @@ void __init cpu_smt_disable(bool force)pr_info ("SMT: disabled\n" ); cpu_smt_control =CPU_SMT_DISABLED ; } + cpu_smt_num_threads =1 ; }/* * The decision whether SMT is supported can only be done after the full * CPU identification. Called from architecture code. */ -void __init cpu_smt_check_topology (void ) +void __init cpu_smt_set_num_threads (unsigned int num_threads, +unsigned int max_threads) { +WARN_ON (!num_threads || (num_threads > max_threads)); +if (!topology_smt_supported ()) cpu_smt_control =CPU_SMT_NOT_SUPPORTED ; + + cpu_smt_max_threads = max_threads; + +/* +* If SMT has been disabled via the kernel command line or SMT is +* not supported, set cpu_smt_num_threads to 1 for consistency. +* If enabled, take the architecture requested number of threads +* to bring up into account. +*/ +if (cpu_smt_control !=CPU_SMT_ENABLED ) + cpu_smt_num_threads =1 ; +else if (num_threads < cpu_smt_num_threads) + cpu_smt_num_threads = num_threads; }static int __init smt_cmdline_disable (char *str)
Signature · 1 line
2.41.0
PATCH v2 4/9 cpu/SMT: Remove topology_smt_supported()
In reply to Laurent DufourSince the maximum number of threads is now passed to cpu_smt_set_num_threads(), checking that value is enough to know if SMT is supported.
--- arch/x86/include/asm/topology.h | 2 -- arch/x86/kernel/smpboot.c | 8 -------- kernel/cpu.c | 2 +- 3 files changed, 1 insertion(+), 11 deletions(-)
arch/x86/include/asm/topology.h +0 -2
@@ -143,7 +143,6 @@ int topology_update_die_map(unsigned int dieid, unsigned int cpu);int topology_phys_to_logical_pkg (unsigned int pkg);int topology_phys_to_logical_die (unsigned int die,unsigned int cpu);bool topology_is_primary_thread (unsigned int cpu); -bool topology_smt_supported (void );#else #define topology_max_packages () (1) static inline int
@@ -156,7 +155,6 @@ static inline int topology_phys_to_logical_die(unsigned int die,static inline int topology_max_die_per_package (void ) {return 1 ; }static inline int topology_max_smt_threads (void ) {return 1 ; }static inline bool topology_is_primary_thread (unsigned int cpu) {return true; } -static inline bool topology_smt_supported (void ) {return false; }#endif static inline void arch_fix_phys_package_id (int num,u32 slot)
arch/x86/kernel/smpboot.c +0 -8
@@ -278,14 +278,6 @@ bool topology_is_primary_thread(unsigned int cpu)return apic_id_is_primary_thread (per_cpu (x86_cpu_to_apicid, cpu)); } -/** -* topology_smt_supported - Check whether SMT is supported by the CPUs -*/ -bool topology_smt_supported (void ) -{ -return smp_num_siblings >1 ; -} -/** * topology_phys_to_logical_pkg - Map a physical package id to a logical *
kernel/cpu.c +1 -1
@@ -442,7 +442,7 @@ void __init cpu_smt_set_num_threads(unsigned int num_threads, {WARN_ON (!num_threads || (num_threads > max_threads)); -if (!topology_smt_supported ()) +if (max_threads ==1 ) cpu_smt_control =CPU_SMT_NOT_SUPPORTED ; cpu_smt_max_threads = max_threads;
Signature · 1 line
2.41.0
PATCH v2 5/9 cpu/SMT: Create topology_smt_thread_allowed()
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Some architectures allows partial SMT states, ie. when not all SMT threads are brought online.
To support that, add an architecture helper which checks whether a given CPU is allowed to be brought online depending on how many SMT threads are currently enabled. Since this is only applicable to architecture supporting partial SMT, only these architectures should select the new configuration variable CONFIG_SMT_NUM_THREADS_DYNAMIC. For the other architectures, not supporting the partial SMT states, there is no need to define topology_cpu_smt_allowed(), the generic code assumed that all the threads are allowed or only the primary ones.
Call the helper from cpu_smt_enable(), and cpu_smt_allowed() when SMT is enabled, to check if the particular thread should be onlined. Notably, also call it from cpu_smt_disable() if CPU_SMT_ENABLED, to allow offlining some threads to move from a higher to lower number of threads online.
--- arch/Kconfig | 3 +++ kernel/cpu.c | 24 +++++++++++++++++++++++- 2 files changed, 26 insertions(+), 1 deletion(-)
arch/Kconfig +3 -0
@@ -34,6 +34,9 @@ config ARCH_HAS_SUBPAGE_FAULTS config HOTPLUG_SMT bool +config SMT_NUM_THREADS_DYNAMIC + bool + config GENERIC_ENTRY bool
kernel/cpu.c +23 -1
@@ -466,9 +466,23 @@ static int __init smt_cmdline_disable(char *str) }early_param ("nosmt" , smt_cmdline_disable); +/* +* For Archicture supporting partial SMT states check if the thread is allowed. +* Otherwise this has already been checked through cpu_smt_max_threads when +* setting the SMT level. +*/ +static inline bool cpu_smt_thread_allowed (unsigned int cpu) +{ +#ifdef CONFIG_SMT_NUM_THREADS_DYNAMIC +return topology_smt_thread_allowed (cpu); +#else +return true; +#endif +} +static inline bool cpu_smt_allowed (unsigned int cpu) { -if (cpu_smt_control ==CPU_SMT_ENABLED ) +if (cpu_smt_control ==CPU_SMT_ENABLED &&cpu_smt_thread_allowed (cpu))return true;if (topology_is_primary_thread (cpu))
@@ -2283,6 +2297,12 @@ int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval)for_each_online_cpu (cpu) {if (topology_is_primary_thread (cpu))continue ; +/* +* Disable can be called with CPU_SMT_ENABLED when changing +* from a higher to lower number of SMT threads per core. +*/ +if (ctrlval ==CPU_SMT_ENABLED &&cpu_smt_thread_allowed (cpu)) +continue ; ret =cpu_down_maps_locked (cpu,CPUHP_OFFLINE );if (ret)break ;
@@ -2317,6 +2337,8 @@ int cpuhp_smt_enable(void)/* Skip online CPUs and CPUs on offline nodes */ if (cpu_online (cpu) || !node_online (cpu_to_node (cpu)))continue ; +if (!cpu_smt_thread_allowed (cpu)) +continue ; ret =_cpu_up (cpu,0 ,CPUHP_ONLINE );if (ret)break ;
Signature · 1 line
2.41.0
PATCH v2 6/9 cpu/SMT: Allow enabling partial SMT states via sysfs
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Add support to the /sys/devices/system/cpu/smt/control interface for enabling a specified number of SMT threads per core, including partial SMT states where not all threads are brought online.
The current interface accepts "on" and "off", to enable either 1 or all SMT threads per core.
This commit allows writing an integer, between 1 and the number of SMT threads supported by the machine. Writing 1 is a synonym for "off", 2 or more enables SMT with the specified number of threads.
When reading the file, if all threads are online "on" is returned, to avoid changing behaviour for existing users. If some other number of threads is online then the integer value is returned.
Architectures like x86 only supporting 1 thread or all threads, should not define CONFIG_SMT_NUM_THREADS_DYNAMIC. Architecture supporting partial SMT states, like PowerPC, should define it.
--- .../ABI/testing/sysfs-devices-system-cpu | 1 + kernel/cpu.c | 58 ++++++++++++++----- 2 files changed, 43 insertions(+), 16 deletions(-)
Documentation/ABI/testing/sysfs-devices-system-cpu +1 -0
@@ -555,6 +555,7 @@ Description: Control Symmetric Multi Threading (SMT) ================ ========================================= "on" SMT is enabled "off" SMT is disabled + "<N>" SMT is enabled with N threads per core. "forceoff" SMT is force disabled. Cannot be changed. "notsupported" SMT is not supported by the CPU "notimplemented" SMT runtime toggling is not
kernel/cpu.c +42 -16
89 lines not on this page · raw message
Signature · 1 line
2.41.0
kernel test robot
build botRe: [PATCH v2 6/9] cpu/SMT: Allow enabling partial SMT states via sysfs
kernel test robot noticed the following build errors:
Hi Laurent,
kernel test robot noticed the following build errors:
[auto build test ERROR on powerpc/next]
[also build test ERROR on powerpc/fixes tip/x86/core v6.4] [cannot apply to tip/smp/core linus/master next-20230628] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch#_base_tree_information]
url: https://github.com/intel-lab-lkp/linux/commits/Laurent-Dufour/cpu-SMT-Move-SMT-prototypes-into-cpu_smt-h/20230628-181323 base: https://git.kernel.org/pub/scm/linux/kernel/git/powerpc/linux.git next patch link: https://lore.kernel.org/r/20230628100558.43482-7-ldufour%40linux.ibm.com patch subject: [PATCH v2 6/9] cpu/SMT: Allow enabling partial SMT states via sysfs config: arm-randconfig-r025-20230628 (https://download.01.org/0day-ci/archive/20230628/[email protected]/config) compiler: clang version 17.0.0 (https://github.com/llvm/llvm-project.git 4a5ac14ee968ff0ad5d2cc1ffa0299048db4c88a) reproduce: (https://download.01.org/0day-ci/archive/20230628/[email protected]/reproduce)
If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/
All errors (new ones prefixed by >>):
>> kernel/cpu.c:2606:29: error: use of undeclared identifier 'cpu_smt_max_threads'; did you mean 'sysctl_max_threads'?
2606 | cpu_smt_num_threads != cpu_smt_max_threads)
| ^~~~~~~~~~~~~~~~~~~
| sysctl_max_threads
include/linux/compiler.h:56:47: note: expanded from macro 'if'
56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) )
| ^
include/linux/compiler.h:58:52: note: expanded from macro '__trace_if_var'
58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond))
| ^
include/linux/sysctl.h:294:5: note: 'sysctl_max_threads' declared here
294 | int sysctl_max_threads(struct ctl_table *table, int write, void *buffer,
| ^
>> kernel/cpu.c:2606:29: error: use of undeclared identifier 'cpu_smt_max_threads'; did you mean 'sysctl_max_threads'?
2606 | cpu_smt_num_threads != cpu_smt_max_threads)
| ^~~~~~~~~~~~~~~~~~~
| sysctl_max_threads
include/linux/compiler.h:56:47: note: expanded from macro 'if'
56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) )
| ^
include/linux/compiler.h:58:61: note: expanded from macro '__trace_if_var'
58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond))
| ^
include/linux/sysctl.h:294:5: note: 'sysctl_max_threads' declared here
294 | int sysctl_max_threads(struct ctl_table *table, int write, void *buffer,
| ^
>> kernel/cpu.c:2606:29: error: use of undeclared identifier 'cpu_smt_max_threads'; did you mean 'sysctl_max_threads'?
2606 | cpu_smt_num_threads != cpu_smt_max_threads)
| ^~~~~~~~~~~~~~~~~~~
| sysctl_max_threads
include/linux/compiler.h:56:47: note: expanded from macro 'if'
56 | #define if(cond, ...) if ( __trace_if_var( !!(cond , ## __VA_ARGS__) ) )
| ^
include/linux/compiler.h:58:86: note: expanded from macro '__trace_if_var'
58 | #define __trace_if_var(cond) (__builtin_constant_p(cond) ? (cond) : __trace_if_value(cond))
| ^
include/linux/compiler.h:69:3: note: expanded from macro '__trace_if_value'
69 | (cond) ? \
| ^ include/linux/sysctl.h:294:5: note: 'sysctl_max_threads' declared here
294 | int sysctl_max_threads(struct ctl_table *table, int write, void *buffer,
| ^
3 errors generated.
vim +2606 kernel/cpu.c
2594
2595 static ssize_t control_show(struct device *dev,
2596 struct device_attribute *attr, char *buf)
2597 {
2598 const char *state = smt_states[cpu_smt_control];
2599
2600 /*
2601 * If SMT is enabled but not all threads are enabled then show the
2602 * number of threads. If all threads are enabled show "on". Otherwise
2603 * show the state name.
2604 */
2605 if (cpu_smt_control == CPU_SMT_ENABLED &&
> 2606 cpu_smt_num_threads != cpu_smt_max_threads)
2607 return sysfs_emit(buf, "%d\n", cpu_smt_num_threads);
2608
2609 return snprintf(buf, PAGE_SIZE - 2, "%s\n", state);
2610 }
2611
Signature · 2 lines
0-DAY CI Kernel Test Service https://github.com/intel/lkp-tests/wiki
PATCH v2 7/9 powerpc/pseries: Initialise CPU hotplug callbacks earlier
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
As part of the generic HOTPLUG_SMT code, there is support for disabling secondary SMT threads at boot time, by passing "nosmt" on the kernel command line.
The way that is implemented is the secondary threads are brought partly online, and then taken back offline again. That is done to support x86 CPUs needing certain initialisation done on all threads. However powerpc has similar needs, see commit d70a54e2d085 ("powerpc/powernv: Ignore smt-enabled on Power8 and later").
For that to work the powerpc CPU hotplug callbacks need to be registered before secondary CPUs are brought online, otherwise __cpu_disable() fails due to smp_ops->cpu_disable being NULL.
So split the basic initialisation into pseries_cpu_hotplug_init() which can be called early from setup_arch(). The DLPAR related initialisation can still be done later, because it needs to do allocations.
--- arch/powerpc/platforms/pseries/hotplug-cpu.c | 22 ++++++++++++-------- arch/powerpc/platforms/pseries/pseries.h | 2 ++ arch/powerpc/platforms/pseries/setup.c | 2 ++ 3 files changed, 17 insertions(+), 9 deletions(-)
arch/powerpc/platforms/pseries/hotplug-cpu.c +13 -9
@@ -845,15 +845,9 @@ static struct notifier_block pseries_smp_nb = { .notifier_call = pseries_smp_notifier, }; -static int __init pseries_cpu_hotplug_init (void ) +void __init pseries_cpu_hotplug_init (void ) {int qcss_tok; -unsigned int node; - -#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE - ppc_md.cpu_probe = dlpar_cpu_probe; - ppc_md.cpu_release = dlpar_cpu_release; -#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ rtas_stop_self_token =rtas_function_token (RTAS_FN_STOP_SELF ); qcss_tok =rtas_function_token (RTAS_FN_QUERY_CPU_STOPPED_STATE );
@@ -862,12 +856,22 @@ static int __init pseries_cpu_hotplug_init(void) qcss_tok == RTAS_UNKNOWN_SERVICE) {printk (KERN_INFO "CPU Hotplug not supported by firmware " "- disabling.\n" ); -return 0 ; +return ; } smp_ops->cpu_offline_self = pseries_cpu_offline_self; smp_ops->cpu_disable = pseries_cpu_disable; smp_ops->cpu_die = pseries_cpu_die; +} + +static int __init pseries_dlpar_init (void ) +{ +unsigned int node; + +#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE + ppc_md.cpu_probe = dlpar_cpu_probe; + ppc_md.cpu_release = dlpar_cpu_release; +#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ /* Processors can be added/removed only on LPAR */ if (firmware_has_feature (FW_FEATURE_LPAR )) {
@@ -886,4 +890,4 @@ static int __init pseries_cpu_hotplug_init(void)return 0 ; } -machine_arch_initcall (pseries, pseries_cpu_hotplug_init); +machine_arch_initcall (pseries, pseries_dlpar_init);
arch/powerpc/platforms/pseries/pseries.h +2 -0
@@ -75,11 +75,13 @@ static inline int dlpar_hp_pmem(struct pseries_hp_errorlog *hp_elog)#ifdef CONFIG_HOTPLUG_CPU int dlpar_cpu (struct pseries_hp_errorlog *hp_elog); +void pseries_cpu_hotplug_init (void );#else static inline int dlpar_cpu (struct pseries_hp_errorlog *hp_elog) {return -EOPNOTSUPP ; } +static inline void pseries_cpu_hotplug_init (void ) { }#endif /* PCI root bridge prepare function override for pseries */
arch/powerpc/platforms/pseries/setup.c +2 -0
@@ -816,6 +816,8 @@ static void __init pSeries_setup_arch(void)/* Discover PIC type and setup ppc_md accordingly */ smp_init_pseries (); +// Setup CPU hotplug callbacks +pseries_cpu_hotplug_init ();if (radix_enabled () && !mmu_has_feature (MMU_FTR_GTSE ))if (!firmware_has_feature (FW_FEATURE_RPT_INVALIDATE ))
Signature · 1 line
2.41.0
PATCH v2 8/9 powerpc: Add HOTPLUG_SMT support
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Add support for HOTPLUG_SMT, which enables the generic sysfs SMT support files in /sys/devices/system/cpu/smt, as well as the "nosmt" boot parameter.
Implement the recently added hooks to allow partial SMT states, allow any number of threads per core.
Tie the config symbol to HOTPLUG_CPU, which enables it on the major platforms that support SMT. If there are other platforms that want the SMT support that can be tweaked in future.
--- Documentation/admin-guide/kernel-parameters.txt | 4 ++-- arch/powerpc/Kconfig | 2 ++ arch/powerpc/include/asm/topology.h | 15 +++++++++++++++ arch/powerpc/kernel/smp.c | 8 +++++++- 4 files changed, 26 insertions(+), 3 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +2 -2
@@ -3838,10 +3838,10 @@ nosmp [SMP] Tells an SMP kernel to act as a UP kernel, and disable the IO APIC. legacy for "maxcpus=0". - nosmt [KNL,S390] Disable symmetric multithreading (SMT). + nosmt [KNL,S390,PPC] Disable symmetric multithreading (SMT). Equivalent to smt=1. - [KNL,X86] Disable symmetric multithreading (SMT). + [KNL,X86,PPC] Disable symmetric multithreading (SMT). nosmt=force: Force disable SMT, cannot be undone via the sysfs control file.
arch/powerpc/Kconfig +2 -0
@@ -273,6 +273,8 @@ config PPC select HAVE_SYSCALL_TRACEPOINTS select HAVE_VIRT_CPU_ACCOUNTING select HAVE_VIRT_CPU_ACCOUNTING_GEN + select HOTPLUG_SMT if HOTPLUG_CPU + select SMT_NUM_THREADS_DYNAMIC select HUGETLB_PAGE_SIZE_VARIABLE if PPC_BOOK3S_64 && HUGETLB_PAGE select IOMMU_HELPER if PPC64 select IRQ_DOMAIN
arch/powerpc/include/asm/topology.h +15 -0
@@ -143,5 +143,20 @@ static inline int cpu_to_coregroup_id(int cpu)#endif #endif +#ifdef CONFIG_HOTPLUG_SMT +#include <linux/cpu_smt.h> +#include <asm/cputhreads.h> + +static inline bool topology_is_primary_thread (unsigned int cpu) +{ +return cpu ==cpu_first_thread_sibling (cpu); +} + +static inline bool topology_smt_thread_allowed (unsigned int cpu) +{ +return cpu_thread_in_core (cpu) < cpu_smt_num_threads; +} +#endif +#endif /* __KERNEL__ */ #endif /* _ASM_POWERPC_TOPOLOGY_H */
arch/powerpc/kernel/smp.c +7 -1
@@ -1087,7 +1087,7 @@ static int __init init_big_cores(void)void __init smp_prepare_cpus (unsigned int max_cpus) { -unsigned int cpu; +unsigned int cpu, num_threads;DBG ("smp_prepare_cpus\n" );
@@ -1154,6 +1154,12 @@ void __init smp_prepare_cpus(unsigned int max_cpus)if (smp_ops && smp_ops->probe) smp_ops->probe (); + +// Initalise the generic SMT topology support + num_threads =1 ; +if (smt_enabled_at_boot) + num_threads = smt_enabled_at_boot; +cpu_smt_set_num_threads (num_threads, threads_per_core); }void smp_prepare_boot_cpu (void )
Signature · 1 line
2.41.0
PATCH v2 9/9 powerpc/pseries: Honour current SMT state when DLPAR onlining CPUs
In reply to Laurent DufourFrom: Michael Ellerman <[email protected]>
Integrate with the generic SMT support, so that when a CPU is DLPAR onlined it is brought up with the correct SMT mode.
--- arch/powerpc/platforms/pseries/hotplug-cpu.c | 8 ++++++++ 1 file changed, 8 insertions(+)
arch/powerpc/platforms/pseries/hotplug-cpu.c +8 -0
@@ -398,6 +398,14 @@ static int dlpar_online_cpu(struct device_node *dn)for_each_present_cpu (cpu) {if (get_hard_smp_processor_id (cpu) != thread)continue ; + +if (!topology_is_primary_thread (cpu)) { +if (cpu_smt_control !=CPU_SMT_ENABLED ) +break ; +if (!topology_smt_thread_allowed (cpu)) +break ; + } +cpu_maps_update_done ();find_and_update_cpu_nid (cpu); rc =device_online (get_cpu_device (cpu));
Signature · 1 line
2.41.0
Quoted 14 lines · Laurent Dufour
I'm taking over the series Michael sent previously [1] which is smartly reviewing the initial series I sent [2]. This series is addressing the comments sent by Thomas and me on the Michael's one.
Here is a short introduction to the issue this series is addressing:
When a new CPU is added, the kernel is activating all its threads. This leads to weird, but functional, result when adding CPU on a SMT 4 system for instance.
Quoted 9 lines
Here the newly added CPU 1 has 8 threads while the other one has 4 threads active (system has been booted with the 'smt-enabled=4' kernel option):
ltcden3-lp12:~ #
ppc64_cpu--infoCore 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12* 13* 14* 15*This mixed SMT level may confused end users and/or some applications.
Thanks for the patches Laurent.
Is the SMT level retained even when dynamically changing SMT values? I am observing difference in behaviour with and without smt-enabled kernel command line option.
When smt-enabled= option is specified SMT level is retained across cpu core remove and add.
Without this option but changing SMT level during runtime using ppc64_cpu —smt=<level>, the SMT level is not retained after cpu core add.
[root@ltcden8-lp8 ~]# ppc64_cpu —smt=4
[root@ltcden8-lp8 ~]# ppc64_cpu --info
Core 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12 13 14 15 Core 2: 16* 17* 18* 19* 20 21 22 23 Core 3: 24* 25* 26* 27* 28 29 30 31
Remove a core, SMT level is retained.
[root@ltcden8-lp8 ~]# ppc64_cpu --info
Core 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12 13 14 15 Core 2: 16* 17* 18* 19* 20 21 22 23
[root@ltcden8-lp8 ~]#
Add 3 cores, SMT level is not retained.
[ 496.600648] Fallback order for Node 1: 1 0 [ 496.600655] Built 1 zonelists, mobility grouping on. Total pages: 1228159 [ 496.600676] Policy zone: Normal [ 496.661173] WARNING: workqueue cpumask: online intersect > possible intersect [ 499.530646] Fallback order for Node 3: 3 0 [ 499.530655] Built 2 zonelists, mobility grouping on. Total pages: 1228159 [ 499.530675] Policy zone: Normal
ppc64_cpu --info
Core 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12 13 14 15 Core 2: 16* 17* 18* 19* 20 21 22 23 Core 3: 24* 25* 26* 27* 28* 29* 30* 31* Core 4: 32* 33* 34* 35* 36* 37* 38* 39* Core 5: 40* 41* 42* 43* 44* 45* 46* 47*
[root@ltcden8-lp8 ~]#
- Sachin
Michael Ellerman
reviewerQuoted 28 lines · Sachin Sant
Quoted 12 lines · Laurent Dufour
I'm taking over the series Michael sent previously [1] which is smartly reviewing the initial series I sent [2]. This series is addressing the comments sent by Thomas and me on the Michael's one.
Here is a short introduction to the issue this series is addressing:
When a new CPU is added, the kernel is activating all its threads. This leads to weird, but functional, result when adding CPU on a SMT 4 system for instance.
Quoted 9 lines
Here the newly added CPU 1 has 8 threads while the other one has 4 threads active (system has been booted with the 'smt-enabled=4' kernel option):
ltcden3-lp12:~ #
ppc64_cpu--infoCore 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12* 13* 14* 15*This mixed SMT level may confused end users and/or some applications.
Thanks for the patches Laurent.
Is the SMT level retained even when dynamically changing SMT values? I am observing difference in behaviour with and without smt-enabled kernel command line option.
Quoted 6 lines
When smt-enabled= option is specified SMT level is retained across cpu core remove and add.
Without this option but changing SMT level during runtime using
ppc64_cpu—smt=<level>, the SMT level is not retained after cpu core add.
That's because ppc64_cpu is not using the sysfs SMT control file, it's just onlining/offlining threads manually.
If you run:
$ ppc64_cpu --smt=4
And then also do:
$ echo 4 > /sys/devices/system/cpu/smt/control
It should work as expected?
ppc64_cpu will need to be updated to do that automatically.
cheers
Le 29/06/2023 à 13:10, Michael Ellerman a écrit :
Quoted 42 lines
Quoted 28 lines · Sachin Sant
Quoted 12 lines · Laurent Dufour
I'm taking over the series Michael sent previously [1] which is smartly reviewing the initial series I sent [2]. This series is addressing the comments sent by Thomas and me on the Michael's one.
Here is a short introduction to the issue this series is addressing:
When a new CPU is added, the kernel is activating all its threads. This leads to weird, but functional, result when adding CPU on a SMT 4 system for instance.
Quoted 9 lines
Here the newly added CPU 1 has 8 threads while the other one has 4 threads active (system has been booted with the 'smt-enabled=4' kernel option):
ltcden3-lp12:~ #
ppc64_cpu--infoCore 0: 0* 1* 2* 3* 4 5 6 7 Core 1: 8* 9* 10* 11* 12* 13* 14* 15*This mixed SMT level may confused end users and/or some applications.
Thanks for the patches Laurent.
Is the SMT level retained even when dynamically changing SMT values? I am observing difference in behaviour with and without smt-enabled kernel command line option.
Quoted 6 lines
When smt-enabled= option is specified SMT level is retained across cpu core remove and add.
Without this option but changing SMT level during runtime using
ppc64_cpu—smt=<level>, the SMT level is not retained after cpu core add.That's because
ppc64_cpuis not using the sysfs SMT control file, it's just onlining/offlining threads manually.If you run:
$ ppc64_cpu --smt=4
Quoted 7 lines
And then also do:
$ echo 4 > /sys/devices/system/cpu/smt/controlIt should work as expected?
ppc64_cpuwill need to be updated to do that automatically.
Hi Sachin and Michael,
Yes, ppc64_cpu will need an update, and I have a patch ready to be sent once this series will be accepted.
By the way, I've a fix for the build issue reported against the patch 6/9. I'll send a v3 soon.
Cheers,
Laurent.
Quoted 9 lines
Quoted 5 lines
Without this option but changing SMT level during runtime using
ppc64_cpu—smt=<level>, the SMT level is not retained after cpu core add.That's because
ppc64_cpuis not using the sysfs SMT control file, it's just onlining/offlining threads manually.
Quoted 8 lines
If you run:
$ ppc64_cpu --smt=4And then also do:
$ echo 4 > /sys/devices/system/cpu/smt/controlIt should work as expected?
Thanks Michael. Yes this works. The SMT level is preserved after a core add.
- Sachin