x86/resctrl: Enable user to view and select thread throttling mode
Subsystems (3)
Reinette Chatre
maintainerv5 cover x86/resctrl: Enable user to view and select thread throttling mode
V4 upstream submission available from:
https://lore.kernel.org/lkml/[email protected]
Patches apply against x86/cache branch commit 0c4d5ba1b998e of tip repo atgit://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git
Changes since V4:
- Pick up Babu's "Reviewed-by" tags.
- Three checks are performed before the MBA_CFG register is updated from its cache. Move all checks to the same if statement. (Babu)
- Remove unnecessary return statement when there is only a switch statement in the function that is already handling all cases. (Babu)
- Remove "mode" local variable from rdtgroup_mode_write(). This variable was previously used to create shorter lines with the original strcmp() code that was removed in patch 4/4.
- Andy pointed out that the repeated assignment to rdtgrp->mode could be replaced by a single assignment after all the checks. This was initially rejected because it would let the "RDT_MODE_PSEUDO_LOCKED" assignment slip through. Even so, Andy's feedback revealed that the new changes unintentionally let a user's attempt at setting the mode to pseudo-locked be silently ignored where it previously reported an error. Restore original user space behavior by returning success when user attempts to change any mode when it is already the current mode (including pseudo-locked) and returning failure when user attempts to set the mode to pseudo-locked. After this change it is possible to follow Andy's original suggestion of using a single assignment. (Andy)
V3 upstream submission available from:
https://lore.kernel.org/lkml/[email protected]
Patches apply against x86/cache branch of tip repo atgit://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git
Changes since V3:
- Maintain the thread throttling mode as a property ("arch_throttle_mode") of the memory bandwidth allocation resource
instead of calling a function that queries the system's model each time this information is needed. Use this new property generically throughout with the goal of being independent of architecture. (Babu)
- Remove "intel" from thread_throttle_mode_init_intel_rw() and thread_throttle_mode_init_intel_ro() in anticipation of usage by other architectures.
- Use function parameter to update_mba_cfg() directly instead of having local variable point to it. (Fenghua)
- Remove unnecessary additional check whether platform supports feature from the "thread_throttle_mode" callback. The file will only be accessible on platforms that support the feature.
- Rework commit message of first patch to be more complete regarding support of all architectures after incorporating AMD feedback.
- View the thread throttle mode with rdtgroup mutex held since it is using cached information that may be changed concurrently.
- Remove unnecessary empty line. (Babu)
V2 upstream submission available from:
https://lore.kernel.org/lkml/[email protected]
Changes since V2:
- Rebase on top of recently merged series "x86/resctrl: Support wider MBM counters". Small change needed to take into account asm/resctrl_sched.h -> asm/resctrl.h name change.
- Fix rST formatting of documentation (resctrl_ui.rst) describing new "thread_throttle_mode" resctrl file.
- Use boot_cpu_has() instead of static_cpu_has() when determining what to display to user (slow path).
V1 upstream submission available from:
https://lore.kernel.org/lkml/[email protected]
A notable change since V1 is the inclusion of two additional patches from Fenghua Yu that introduce the new per-thread MBA feature. These changes are added to this series because they are small and closely related to the original submission. The per-thread MBA feature is a hardware advancement that requires no software interface changes. The patches added just enumerate the feature and expose it to userspace by showing "per-thread" in the new resctrl file "thread_throttle_mode" to help user applications fine tune performance.
There are currently a few resctrl changes outstanding for upstream inclusion. To support their consideration all outstanding resctrl patches can be viewed at https://github.com/rchatre/linux.git (branch resctrl/next)
Changes since V1 (also documented within patches to which they apply):
- Rebased on top of James Morse's CDP fix
(https://lore.kernel.org/lkml/[email protected])
- Remove RF_UNINITIALIZED (having uninitialized be represented with ones creates too much confusion), replace with an explicit check of rft->fflags in rdtgroup_add_files() (Fenghua Yu)
- Rename MBA_THREAD_THROTTLE_MODE to MBA_THROTTLE_MODE_MASK to clarify its use as a mask (Tony Luck)
- Introduce explicit MBA_THROTTLE_MODE_MAX instead of implying it is the opposite of min and use these values (min and max) explicitly whenever testing/setting the throttle mode value (Tony Luck)
- Add __init attribute to thread_throttle_mode_init_intel_rw() and thread_throttle_mode_init_intel_ro() since they are only needed during initialization (Fenghua Yu)
- Remove MBA_CFG MSR reads and error checking so that the patch is simpler and easier to review (Fenghua Yu)
- Ensure CPU hotplug lock is taken when writing register on multiple CPUs (Fenghua Yu)
- Use CPU mask already maintained as part of domains to determine which CPUs to update MBA register on (Fenghua Yu)
- Maintain MBA configuration register contents to support use case when not all CPUs of a package are online when configuration is set from user space
- Use seq_puts() instead of seq_printf() when simple strings are printed
- Set MBA configuration to default when resctrl is unmounted
- Complete rewrite of "thread_throttle_mode" documentation (Tony Luck)
- Remove unnecessary checks on user input (Andy Shevchenko)
- Change code style surrounding usage of sysfs_match_string() (Andy Shevchenko)
From V1 submission:
The first patch in this series introduces a new resctrl file, "thread_throttle_mode", on Intel systems that exposes to the user how per-thread values are allocated to a core. This is added in support of newer Intel systems that can be configured to allocate either maximum or minimum throttling of the per-thread CLOS values to the core.
Details about the feature can be found in the commit description and in Chapter 9 of the most recent Intel ISE available from
https://software.intel.com/sites/default/files/managed/c5/15/architecture-instruction-set-extensions-programming-reference.pdf
The first patch parses user input with the appropriate sysfs API that has not previously been used in resctrl. The second (later in the fourth) patch is added as a subsequent cleanup that switches existing resctrl string parsing code to also use this appropriate API.
Fenghua Yu (2):
x86/resctrl: Enumerate per-thread MBA
x86/resctrl: Enable per-thread MBA
Reinette Chatre (2):
x86/resctrl: Enable user to view and select thread throttling mode x86/resctrl: Use appropriate API for strings terminated by newline
Documentation/x86/resctrl_ui.rst | 22 ++- arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/kernel/cpu/cpuid-deps.c | 1 + arch/x86/kernel/cpu/resctrl/core.c | 52 ++++++ arch/x86/kernel/cpu/resctrl/internal.h | 49 ++++- arch/x86/kernel/cpu/resctrl/rdtgroup.c | 247 +++++++++++++++++++++++-- arch/x86/kernel/cpu/scattered.c | 1 + 7 files changed, 345 insertions(+), 28 deletions(-)
Signature · 1 line
2.21.0
Reinette Chatre
maintainerPATCH v5 1/4 x86/resctrl: Enable user to view and select thread throttling mode
Intel Memory Bandwidth Allocation (MBA) control is provided per processor core. At the same time different CLOS, configured with different bandwidth percentages, can be assigned to the hardware threads sharing a core. In the original implementation of MBA the maximum throttling of the per-thread CLOS is allocated to the core. Specifically, the lower bandwidth percentage is allocated to the core.
Newer systems can be configured to allocate either maximum or minimum throttling of the per-thread CLOS values to the core.
Introduce a new resctrl file, "thread_throttle_mode", on Intel systems that exposes to the user how per-thread values are allocated to a core. On systems that support the original MBA implementation the file will always display "max". On systems that can be configured the possible values are "min" or "max" that the user can modify by writing these same words to the file.
AMD confirmed in
https://lore.kernel.org/lkml/[email protected]
that AMD bandwidth allocation is already at thread level. But AMD does not use memory delay throttle model to control the allocation like Intel does. So, to avoid any confusion the thread throttling mode would be UNDEFINED on AMD systems and the "thread_throttle_mode" file will not be visible.
---
Changes since V4:
- Three checks are performed before the MBA_CFG register is updated from its cache. Move all checks to the same if statement. (Babu)
- Remove unnecessary return statement when there is only a switch statement in the function that is already handling all cases. (Babu)
Documentation/x86/resctrl_ui.rst | 19 ++- arch/x86/kernel/cpu/resctrl/core.c | 49 +++++++ arch/x86/kernel/cpu/resctrl/internal.h | 47 +++++- arch/x86/kernel/cpu/resctrl/rdtgroup.c | 196 ++++++++++++++++++++++++- 4 files changed, 302 insertions(+), 9 deletions(-)
Documentation/x86/resctrl_ui.rst +17 -2
@@ -138,6 +138,19 @@ with respect to allocation: non-linear. This field is purely informational only. +"thread_throttle_mode": + Indicator (on some CPU models control) on Intel systems + of how tasks running on threads of a physical core are + throttled in cases where they request different memory + bandwidth percentages: + + "min": + the largest percentage is applied + to all threads + "max": + the smallest percentage is applied + to all threads + If RDT monitoring is available there will be an "L3_MON" directory with the following files:
@@ -364,8 +377,10 @@ to the next control step available on the hardware. The bandwidth throttling is a core specific mechanism on some of Intel SKUs. Using a high bandwidth and a low bandwidth setting on two threads -sharing a core will result in both threads being throttled to use the -low bandwidth. The fact that Memory bandwidth allocation(MBA) is a core +sharing a core may result in both threads being throttled to use the +low bandwidth (see "thread_throttle_mode"). + +The fact that Memory bandwidth allocation(MBA) may be a core specific mechanism where as memory bandwidth monitoring(MBM) is done at the package level may lead to confusion when users try to apply control via the MBA and then monitor the bandwidth to see if the controls are
arch/x86/kernel/cpu/resctrl/core.c +49 -0
73 lines not on this page · raw message
arch/x86/kernel/cpu/resctrl/internal.h +41 -6
92 lines not on this page · raw message
arch/x86/kernel/cpu/resctrl/rdtgroup.c +195 -1
238 lines not on this page · raw message
Signature · 1 line
2.21.0
Reinette Chatre
maintainerPATCH v5 2/4 x86/resctrl: Enumerate per-thread MBA
In reply to Reinette ChatreFrom: Fenghua Yu <[email protected]>
Some systems support per-thread Memory Bandwidth Allocation (MBA) which applies a throttling delay value to each hardware thread instead of to a core. Per-thread MBA is enumerated by CPUID.
No feature flag is shown in /proc/cpuinfo. User applications need to check a resctrl throttling mode info file to know if the feature is supported.
---
Changes since V4:
- Pick up Babu's "Reviewed-by" tag.
arch/x86/include/asm/cpufeatures.h | 1 + arch/x86/kernel/cpu/cpuid-deps.c | 1 + arch/x86/kernel/cpu/scattered.c | 1 + 3 files changed, 3 insertions(+)
arch/x86/include/asm/cpufeatures.h +1 -0
@@ -286,6 +286,7 @@#define X86_FEATURE_FENCE_SWAPGS_USER (11*32+ 4)/* "" LFENCE in user entry SWAPGS path */ #define X86_FEATURE_FENCE_SWAPGS_KERNEL (11*32+ 5)/* "" LFENCE in kernel entry SWAPGS path */ #define X86_FEATURE_SPLIT_LOCK_DETECT (11*32+ 6)/* #AC for split lock */ +#define X86_FEATURE_PER_THREAD_MBA (11*32+ 7)/* "" Per-thread Memory Bandwidth Allocation */ /* Intel-defined CPU features, CPUID level 0x00000007:1 (EAX), word 12 */ #define X86_FEATURE_AVX512_BF16 (12*32+ 5)/* AVX512 BFLOAT16 instructions */
arch/x86/kernel/cpu/cpuid-deps.c +1 -0
@@ -69,6 +69,7 @@ static const struct cpuid_dep cpuid_deps[] = { { X86_FEATURE_CQM_MBM_TOTAL, X86_FEATURE_CQM_LLC }, { X86_FEATURE_CQM_MBM_LOCAL, X86_FEATURE_CQM_LLC }, { X86_FEATURE_AVX512_BF16, X86_FEATURE_AVX512VL }, + { X86_FEATURE_PER_THREAD_MBA, X86_FEATURE_MBA }, {} };
arch/x86/kernel/cpu/scattered.c +1 -0
@@ -35,6 +35,7 @@ static const struct cpuid_bit cpuid_bits[] = { { X86_FEATURE_CDP_L3, CPUID_ECX, 2, 0x00000010, 1 }, { X86_FEATURE_CDP_L2, CPUID_ECX, 2, 0x00000010, 2 }, { X86_FEATURE_MBA, CPUID_EBX, 3, 0x00000010, 0 }, + { X86_FEATURE_PER_THREAD_MBA, CPUID_ECX, 0, 0x00000010, 3 }, { X86_FEATURE_HW_PSTATE, CPUID_EDX, 7, 0x80000007, 0 }, { X86_FEATURE_CPB, CPUID_EDX, 9, 0x80000007, 0 }, { X86_FEATURE_PROC_FEEDBACK, CPUID_EDX, 11, 0x80000007, 0 },
Signature · 1 line
2.21.0
Reinette Chatre
maintainerPATCH v5 3/4 x86/resctrl: Enable per-thread MBA
In reply to Reinette ChatreFrom: Fenghua Yu <[email protected]>
Current Memory Bandwidth Allocation (MBA) hardware has a limitation:
all threads on the same core must have the same delay value. If there are different delay values across threads on one core, the original MBA implementation allocates the max delay value to the core and an updated implementation allocates either min or max delay value specified by a configuration MSR across threads on the core.
Newer systems support per-thread MBA such that each thread is allocated with its own delay value.
If per-thread MBA is supported, report "per-thread" in resctrl file "info/MB/thread_throttle_mode" to let user applications know memory bandwidth is allocated per thread and help them fine tune MBA on thread level.
---
Changes since V4:
- Pick up Babu's "Reviewed-by" tag.
Documentation/x86/resctrl_ui.rst | 3 +++ arch/x86/kernel/cpu/resctrl/core.c | 5 ++++- arch/x86/kernel/cpu/resctrl/internal.h | 2 ++ arch/x86/kernel/cpu/resctrl/rdtgroup.c | 11 +++++++++++ 4 files changed, 20 insertions(+), 1 deletion(-)
Documentation/x86/resctrl_ui.rst +3 -0
@@ -150,6 +150,9 @@ with respect to allocation: "max": the smallest percentage is applied to all threads + "per-thread": + bandwidth percentages are directly applied to + the threads running on the core If RDT monitoring is available there will be an "L3_MON" directory with the following files:
arch/x86/kernel/cpu/resctrl/core.c +4 -1
@@ -304,7 +304,10 @@ static bool __get_mem_config_intel(struct rdt_resource *r) } r->data_width =3 ; -if (mba_cfg_supports_min_max_intel ()) { +if (boot_cpu_has (X86_FEATURE_PER_THREAD_MBA )) { + r->membw.arch_throttle_mode =THREAD_THROTTLE_PER_THREAD ; +thread_throttle_mode_init_ro (); + }else if (mba_cfg_supports_min_max_intel ()) { r->membw.arch_throttle_mode =THREAD_THROTTLE_MIN_MAX ;thread_throttle_mode_init_rw (); }else {
arch/x86/kernel/cpu/resctrl/internal.h +2 -0
@@ -391,11 +391,13 @@ struct rdt_cache {* @THREAD_THROTTLE_MAX_ONLY: Memory bandwidth is throttled at the core * always using smallest bandwidth percentage * assigned to threads, aka "max throttling" +* @THREAD_THROTTLE_PER_THREAD: Memory bandwidth is throttled at the thread */ enum membw_throttle_mode {THREAD_THROTTLE_UNDEFINED =0 ,THREAD_THROTTLE_MIN_MAX ,THREAD_THROTTLE_MAX_ONLY , +THREAD_THROTTLE_PER_THREAD , };/**
arch/x86/kernel/cpu/resctrl/rdtgroup.c +11 -0
@@ -1038,6 +1038,11 @@ static int max_threshold_occ_show(struct kernfs_open_file *of,* with the maximum delay value that from the software interface will be * the minimum of the bandwidth percentages assigned to the hardware threads * sharing the core. +* +* Some systems (identified by X86_FEATURE_PER_THREAD_MBA enumerated via CPUID) +* support per-thread MBA. On these systems hardware doesn't apply the minimum +* or maximum delay value to all threads in a core. Instead, a thread is +* allocated with the delay value that is assigned to the thread. */ static int rdt_thread_throttle_mode_show (struct kernfs_open_file *of,struct seq_file *seq,void *v)
@@ -1047,12 +1052,18 @@ static int rdt_thread_throttle_mode_show(struct kernfs_open_file *of,mutex_lock (&rdtgroup_mutex); +if (r->membw.arch_throttle_mode ==THREAD_THROTTLE_PER_THREAD ) { +seq_puts (seq,"per-thread\n" ); + goto out; + } +if (r->membw.arch_throttle_mode ==THREAD_THROTTLE_MIN_MAX ) throttle_mode = mba_cfg_msr &MBA_THROTTLE_MODE_MASK ;seq_puts (seq, throttle_mode ==MBA_THROTTLE_MODE_MIN ?"min\n" :"max\n" ); +out:mutex_unlock (&rdtgroup_mutex);return 0 ; }
Signature · 1 line
2.21.0
Reinette Chatre
maintainerPATCH v5 4/4 x86/resctrl: Use appropriate API for strings terminated by newline
In reply to Reinette ChatreThe user input to files in the resctrl filesystem are expected to be terminated with a newline. Testing the user input includes a test for the presence of a newline and then replacing the newline with NUL byte followed by comparison using strcmp().
sysfs_streq() exists to test if strings are equal, treating both NUL and newline-then-NUL as equivalent string terminations. Even more, sysfs_match_string() exists to match a given string in an array using sysfs_streq().
Replace existing strcmp() comparisons of strings that are terminated with a newline with more appropriate sysfs_streq() via the sysfs_match_string() API that can perform the match across the different mode strings that are already maintained in an array.
---
Changes since V4:
- Remove "mode" local variable from rdtgroup_mode_write(). This variable was previously used to create shorter lines with the original strcmp() code that was removed in patch 4/4.
- Andy pointed out that the repeated assignment to rdtgrp->mode could be replaced by a single assignment after all the checks. This was initially rejected because it would let the "RDT_MODE_PSEUDO_LOCKED" assignment slip through. Even so, Andy's feedback revealed that the new changes unintentionally let a user's attempt at setting the mode to pseudo-locked be silently ignored where it previously reported an error. Restore original user space behavior by returning success when user attempts to change any mode when it is already the current mode (including pseudo-locked) and returning failure when user attempts to set the mode to pseudo-locked. After this change it is possible to follow Andy's original suggestion of using a single assignment. (Andy)
arch/x86/kernel/cpu/resctrl/rdtgroup.c | 40 ++++++++++++++------------ 1 file changed, 21 insertions(+), 19 deletions(-)
arch/x86/kernel/cpu/resctrl/rdtgroup.c +21 -19
@@ -1414,13 +1414,11 @@ static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, char *buf, size_t nbytes, loff_t off) {struct rdtgroup *rdtgrp; -enum rdtgrp_mode mode; -int ret =0 ; +int user_m; +int ret; -/* Valid input requires a trailing newline */ -if (nbytes ==0 || buf[nbytes -1 ] !='\n' ) +if (nbytes ==0 )return -EINVAL ; - buf[nbytes -1 ] ='\0' ; rdtgrp =rdtgroup_kn_lock_live (of->kn);if (!rdtgrp) {
@@ -1430,29 +1428,33 @@ static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,rdt_last_cmd_clear (); - mode = rdtgrp->mode; + ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ; + goto out; + } + + user_m = ret; + ret =0 ; -if ((!strcmp (buf,"shareable" ) && mode ==RDT_MODE_SHAREABLE ) || - (!strcmp (buf,"exclusive" ) && mode ==RDT_MODE_EXCLUSIVE ) || - (!strcmp (buf,"pseudo-locksetup" ) && - mode ==RDT_MODE_PSEUDO_LOCKSETUP ) || - (!strcmp (buf,"pseudo-locked" ) && mode ==RDT_MODE_PSEUDO_LOCKED )) +/* Do nothing and return success if user asks for current mode */ +if (user_m == rdtgrp->mode) goto out; -if (mode ==RDT_MODE_PSEUDO_LOCKED ) { +if (rdtgrp->mode ==RDT_MODE_PSEUDO_LOCKED ) {rdt_last_cmd_puts ("Cannot change pseudo-locked group\n" ); ret = -EINVAL ; goto out; } -if (!strcmp (buf,"shareable" )) { +if (user_m ==RDT_MODE_SHAREABLE ) {if (rdtgrp->mode ==RDT_MODE_PSEUDO_LOCKSETUP ) { ret =rdtgroup_locksetup_exit (rdtgrp);if (ret) goto out; } - rdtgrp->mode =RDT_MODE_SHAREABLE ; - }else if (!strcmp (buf,"exclusive" )) { + }else if (user_m ==RDT_MODE_EXCLUSIVE ) {if (!rdtgroup_mode_test_exclusive (rdtgrp)) { ret = -EINVAL ; goto out;
@@ -1462,16 +1464,16 @@ static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,if (ret) goto out; } - rdtgrp->mode =RDT_MODE_EXCLUSIVE ; - }else if (!strcmp (buf,"pseudo-locksetup" )) { + }else if (user_m ==RDT_MODE_PSEUDO_LOCKSETUP ) { ret =rdtgroup_locksetup_enter (rdtgrp);if (ret) goto out; - rdtgrp->mode =RDT_MODE_PSEUDO_LOCKSETUP ; - }else { + }else if (user_m ==RDT_MODE_PSEUDO_LOCKED ) {rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); ret = -EINVAL ; + goto out; } + rdtgrp->mode = user_m; out:rdtgroup_kn_unlock (of->kn);
Signature · 1 line
2.21.0
Re: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
Quoted 15 lines · Reinette Chatre
The user input to files in the resctrl filesystem are expected to be terminated with a newline. Testing the user input includes a test for the presence of a newline and then replacing the newline with NUL byte followed by comparison using
strcmp().
sysfs_streq()exists to test if strings are equal, treating both NUL and newline-then-NUL as equivalent string terminations. Even more,sysfs_match_string()exists to match a given string in an array usingsysfs_streq().Replace existing
strcmp()comparisons of strings that are terminated with a newline with more appropriatesysfs_streq()via thesysfs_match_string()API that can perform the match across the different mode strings that are already maintained in an array.
...
Quoted 7 lines
Changes since V4:
- Remove "mode" local variable fromrdtgroup_mode_write(). This variable was previously used to create shorter lines with the originalstrcmp()code that was removed in patch 4/4.
- Andy pointed out that the repeated assignment tordtgrp->modecould be replaced by a single assignment after all the checks. This was initially rejected because it would let the "RDT_MODE_PSEUDO_LOCKED" assignment
Quoted 8 lines
slip through. Even so, Andy's feedback revealed that the new changes unintentionally let a user's attempt at setting the mode to pseudo-locked be silently ignored where it previously reported an error. Restore original user space behavior by returning success when user attempts to change any mode when it is already the current mode (including pseudo-locked) and returning failure when user attempts to set the mode to pseudo-locked. After this change it is possible to follow Andy's original suggestion of using a single assignment. (Andy)
Glad we can do it!
...
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,
Quoted 5 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +4
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ;
This is redundant.
Quoted 2 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +2
-0+ goto out; + }
Signature · 2 lines
With Best Regards, Andy Shevchenko
Re: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
In reply to Reinette ChatreOn Tue, May 19, 2020 at 2:50 AM Reinette Chatre
<[email protected]> wrote:
...
Quoted 4 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +4
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ;
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, · line 1449
Quoted 10 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +6
-0+ goto out; + } + + user_m = ret; + }else if (user_m ==RDT_MODE_PSEUDO_LOCKED ) {rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); ret = -EINVAL ; + goto out; }
Can't we unify latter with a former like
if (ret == RDT_MODE_PSEUDO_LOCKED)
ret = -EINVAL;
if (ret < 0) {
rdt_last_cmd_puts("Unknown or unsupported mode\n");
goto out;
}?
Or closer to initial like
if (ret < 0 || ret == RDT_MODE_PSEUDO_LOCKED) {
rdt_last_cmd_puts("Unknown or unsupported mode\n");
ret = -EINVAL;
goto out;
}Signature · 2 lines
With Best Regards, Andy Shevchenko
Reinette Chatre
maintainerRe: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
Hi Andy,
On a high level the changes from v4 to v5 aimed to address your feedback and also ensure that original user interface behavior is maintained.
Quoted 11 lines · Andy Shevchenko
On Tue, May 19, 2020 at 2:50 AM Reinette Chatre
<[email protected]> wrote:...
Quoted 6 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +6
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ; + goto out; + }
From your previous email ...
Quoted 7 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,
Quoted 5 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +4
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ;This is redundant.
I understand that shadowing an error code is generally of concern. In this case the error code is set to -EINVAL to ensure that it is the same error code that was returned to user space originally and will continue to be so no matter what changes may come to sysfs_match_string().
Quoted 20 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, · line 1449
Quoted 8 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +4
-0+ + user_m = ret; + }else if (user_m ==RDT_MODE_PSEUDO_LOCKED ) {rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); ret = -EINVAL ; + goto out; }Can't we unify latter with a former like
if (ret == RDT_MODE_PSEUDO_LOCKED) ret = -EINVAL; if (ret < 0) { rdt_last_cmd_puts("Unknown or unsupported mode\n"); goto out; }?
Quoted 8 lines
Or closer to initial like
if (ret < 0 || ret == RDT_MODE_PSEUDO_LOCKED) { rdt_last_cmd_puts("Unknown or unsupported mode\n"); ret = -EINVAL; goto out; }
This would have been ideal if done from the start but currently "0" is returned if the current mode is pseudo-locked and user attempts to change the mode to pseudo-locked. Thus, to maintain the current user interface the check if user wants to set pseudo-locked mode is moved after the check if new mode is same as existing mode and thus not unified because that will result in an error returned always when user requests pseudo-locked mode.
Reinette
Re: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
Quoted 3 lines · Reinette Chatre
Quoted 2 lines · Andy Shevchenko
On Tue, May 19, 2020 at 2:50 AM Reinette Chatre
<[email protected]> wrote:
...
Quoted 13 lines
Quoted 6 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, · line 1436
Quoted 6 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +6
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ; + goto out; + }From your previous email ...
Quoted 4 lines
Quoted 3 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +3
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" );
Quoted 8 lines
Quoted 3 lines
Quoted 1 line
+ ret =
-EINVAL;This is redundant.
I understand that shadowing an error code is generally of concern. In this case the error code is set to
-EINVALto ensure that it is the same error code that was returned to user space originally and will continue to be so no matter what changes may come tosysfs_match_string().
It returns -EINVAL and if that will be ever changed this driver would be one of hundreds who suffers.
...
Quoted 9 lines
Quoted 1 line
Can't we unify latter with a former like ...
This would have been ideal if done from the start but currently "0" is returned if the current mode is pseudo-locked and user attempts to change the mode to pseudo-locked. Thus, to maintain the current user interface the check if user wants to set pseudo-locked mode is moved after the check if new mode is same as existing mode and thus not unified because that will result in an error returned always when user requests pseudo-locked mode.
Ah, I see now.
But we can then drop the check from sysfs_match_string() returned value, like
user_m = sysfs_match_string();
if (...) {
...
} else { // w/o even checking for the PSEUDO_LOCKED
...
goto out;
}Can we?
Signature · 2 lines
With Best Regards, Andy Shevchenko
Re: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
Quoted 4 lines · Andy Shevchenko
Quoted 3 lines · Reinette Chatre
Quoted 2 lines · Andy Shevchenko
On Tue, May 19, 2020 at 2:50 AM Reinette Chatre
<[email protected]> wrote:
...
Quoted 10 lines
Quoted 9 lines
Quoted 1 line
Can't we unify latter with a former like ...
This would have been ideal if done from the start but currently "0" is returned if the current mode is pseudo-locked and user attempts to change the mode to pseudo-locked. Thus, to maintain the current user interface the check if user wants to set pseudo-locked mode is moved after the check if new mode is same as existing mode and thus not unified because that will result in an error returned always when user requests pseudo-locked mode.
Quoted 5 lines
Ah, I see now.
But we can then drop the check from
sysfs_match_string()returned value, likeuser_m = sysfs_match_string();
Yes, here some additional checks like
if (user_m == mode) goto out;
Quoted 8 lines
if (...) { ... } else { // w/o even checking for the PSEUDO_LOCKED ... goto out; }Can we?
Signature · 2 lines
With Best Regards, Andy Shevchenko
Reinette Chatre
maintainerRe: [PATCH V5 4/4] x86/resctrl: Use appropriate API for strings terminated by newline
In reply to Andy ShevchenkoHi Andy,
Quoted 24 lines · Andy Shevchenko
Quoted 3 lines · Reinette Chatre
Quoted 2 lines · Andy Shevchenko
On Tue, May 19, 2020 at 2:50 AM Reinette Chatre
<[email protected]> wrote:...
Quoted 17 lines
Quoted 6 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of, · line 1436
Quoted 6 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +6
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ; + goto out; + }From your previous email ...
Quoted 7 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c static ssize_t rdtgroup_mode_write(struct kernfs_open_file *of,
Quoted 5 lines
arch/x86/kernel/cpu/resctrl/rdtgroup.c +4
-0+ ret =sysfs_match_string (rdt_mode_str, buf); +if (ret <0 ) { +rdt_last_cmd_puts ("Unknown or unsupported mode\n" ); + ret = -EINVAL ;This is redundant.
Quoted 7 lines
Quoted 4 lines
I understand that shadowing an error code is generally of concern. In this case the error code is set to
-EINVALto ensure that it is the same error code that was returned to user space originally and will continue to be so no matter what changes may come tosysfs_match_string().It returns
-EINVALand if that will be ever changed this driver would be one of hundreds who suffers.
Not if we keep this change ... but that is no longer of concern with the removal of the check as you propose later.
Quoted 25 lines
...
Quoted 9 lines
Quoted 1 line
Can't we unify latter with a former like ...
This would have been ideal if done from the start but currently "0" is returned if the current mode is pseudo-locked and user attempts to change the mode to pseudo-locked. Thus, to maintain the current user interface the check if user wants to set pseudo-locked mode is moved after the check if new mode is same as existing mode and thus not unified because that will result in an error returned always when user requests pseudo-locked mode.
Ah, I see now.
But we can then drop the check from
sysfs_match_string()returned value, likeuser_m = sysfs_match_string(); if (...) { ... } else { // w/o even checking for the PSEUDO_LOCKED ... goto out; }
Quoted 2 lines
Can we?
Yes, we can. Will do.
Reinette