FAILED: patch "[PATCH] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE" failed to apply to 5.15-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 5.15-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.15.y
git checkout FETCH_HEAD
git cherry-pick -x 964209202ebe1569c858337441e87ef0f9d71416
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2025070818-buddhism-wikipedia-516a@gregkh' --subject-prefix 'PATCH 5.15.y' HEAD^..
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 964209202ebe1569c858337441e87ef0f9d71416 Mon Sep 17 00:00:00 2001
From: Zhang Rui <[email protected]>
Date: Thu, 19 Jun 2025 15:13:40 +0800
Subject: [PATCH] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE
bit cannot be changed
PL1 cannot be disabled on some platforms. The ENABLE bit is still set after software clears it. This behavior leads to a scenario where, upon user request to disable the Power Limit through the powercap sysfs, the ENABLE bit remains set while the CLAMPING bit is inadvertently cleared.
According to the Intel Software Developer's Manual, the CLAMPING bit, "When set, allows the processor to go below the OS requested P states in order to maintain the power below specified Platform Power Limit value."
Thus this means the system may operate at higher power levels than intended on such platforms.
Enhance the code to check ENABLE bit after writing to it, and stop further processing if ENABLE bit cannot be changed.
drivers/powercap/intel_rapl_common.c +17 -1
@@ -341,12 +341,28 @@ static int set_domain_enable(struct powercap_zone *power_zone, bool mode) {struct rapl_domain *rd =power_zone_to_rapl_domain (power_zone);struct rapl_defaults *defaults =get_defaults (rd->rp); +u64 val;int ret;cpus_read_lock (); ret =rapl_write_pl_data (rd,POWER_LIMIT1 ,PL_ENABLE , mode); -if (!ret && defaults->set_floor_freq) +if (ret) + goto end; + + ret =rapl_read_pl_data (rd,POWER_LIMIT1 ,PL_ENABLE , false, &val); +if (ret) + goto end; + +if (mode != val) { +pr_debug ("%s cannot be %s\n" , power_zone->name, +str_enabled_disabled (mode)); + goto end; + } + +if (defaults->set_floor_freq) defaults->set_floor_freq (rd, mode); + +end:cpus_read_unlock ();return ret;
Sasha Levin
maintainerPATCH 1/1 powercap: intel_rapl: Do not change CLAMPING bit if ENABLE bit cannot be changed
From: Zhang Rui <[email protected]>
[ Upstream commit 964209202ebe1569c858337441e87ef0f9d71416 ]
PL1 cannot be disabled on some platforms. The ENABLE bit is still set after software clears it. This behavior leads to a scenario where, upon user request to disable the Power Limit through the powercap sysfs, the ENABLE bit remains set while the CLAMPING bit is inadvertently cleared.
According to the Intel Software Developer's Manual, the CLAMPING bit, "When set, allows the processor to go below the OS requested P states in order to maintain the power below specified Platform Power Limit value."
Thus this means the system may operate at higher power levels than intended on such platforms.
Enhance the code to check ENABLE bit after writing to it, and stop further processing if ENABLE bit cannot be changed.
--- drivers/powercap/intel_rapl_common.c | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-)
drivers/powercap/intel_rapl_common.c +22 -1
@@ -212,12 +212,33 @@ static int find_nr_power_limit(struct rapl_domain *rd)static int set_domain_enable (struct powercap_zone *power_zone,bool mode) {struct rapl_domain *rd =power_zone_to_rapl_domain (power_zone); +u64 val; +int ret;if (rd->state &DOMAIN_STATE_BIOS_LOCKED )return -EACCES ;cpus_read_lock (); -rapl_write_data_raw (rd,PL1_ENABLE , mode); + ret =rapl_write_data_raw (rd,PL1_ENABLE , mode); +if (ret) { +cpus_read_unlock (); +return ret; + } + +/* Check if the ENABLE bit was actually changed */ + ret =rapl_read_data_raw (rd,PL1_ENABLE , true, &val); +if (ret) { +cpus_read_unlock (); +return ret; + } + +if (mode != val) { +pr_debug ("%s cannot be %s\n" , power_zone->name, + mode ?"enabled" :"disabled" ); +cpus_read_unlock (); +return 0 ; + } +if (rapl_defaults->set_floor_freq) rapl_defaults->set_floor_freq (rd, mode);cpus_read_unlock ();
Signature · 1 line
2.39.5
Re: [PATCH 5.15.y] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE bit cannot be changed
Hi Sasha,
Question inline from a backport point of view:
Quoted 50 lines · Sasha Levin
From: Zhang Rui <[email protected]>
[ Upstream commit
964209202ebe1569c858337441e87ef0f9d71416]PL1 cannot be disabled on some platforms. The ENABLE bit is still set after software clears it. This behavior leads to a scenario where, upon user request to disable the Power Limit through the powercap sysfs, the ENABLE bit remains set while the CLAMPING bit is inadvertently cleared.
According to the Intel Software Developer's Manual, the CLAMPING bit, "When set, allows the processor to go below the OS requested P states in order to maintain the power below specified Platform Power Limit value."
Thus this means the system may operate at higher power levels than intended on such platforms.
Enhance the code to check ENABLE bit after writing to it, and stop further processing if ENABLE bit cannot be changed.
Reported-by Srinivas Pandruvada <[email protected]>Fixes 2d281d8196e3 ("PowerCap: Introduce Intel RAPL power capping driver")Cc All applicable <[email protected]>Signed-off-by Zhang Rui <[email protected]>[ rjw: Use str_enabled_disabled() instead of open-coded equivalent ]Signed-off-by Rafael J. Wysocki <[email protected]>[ replaced rapl_write_pl_data() and rapl_read_pl_data() with rapl_write_data_raw() and rapl_read_data_raw() ]Signed-off-by Sasha Levin <[email protected]>--- drivers/powercap/intel_rapl_common.c | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-)drivers/powercap/intel_rapl_common.c +4
-1@@ -212,12 +212,33 @@ static int find_nr_power_limit(struct rapl_domain *rd)static int set_domain_enable (struct powercap_zone *power_zone,bool mode) {struct rapl_domain *rd =power_zone_to_rapl_domain (power_zone); +u64 val; +int ret;if (rd->state &DOMAIN_STATE_BIOS_LOCKED )return -EACCES ;cpus_read_lock (); -rapl_write_data_raw (rd,PL1_ENABLE , mode); + ret =rapl_write_data_raw (rd,PL1_ENABLE , mode); +if (ret) {
drivers/powercap/intel_rapl_common.c static int find_nr_power_limit(struct rapl_domain *rd) · line 233
Quoted 10 lines
drivers/powercap/intel_rapl_common.c +10
-0+cpus_read_unlock (); +return ret; + } + +/* Check if the ENABLE bit was actually changed */ + ret =rapl_read_data_raw (rd,PL1_ENABLE , true, &val); +if (ret) { +cpus_read_unlock (); +return ret; + }
Shouldn't this be rapl_read_data_raw(rd, PL1_ENABLE, false, &val); ?
Thanks
Harshit
Quoted 11 lines
drivers/powercap/intel_rapl_common.c +8
-0+ +if (mode != val) { +pr_debug ("%s cannot be %s\n" , power_zone->name, + mode ?"enabled" :"disabled" ); +cpus_read_unlock (); +return 0 ; + } +if (rapl_defaults->set_floor_freq) rapl_defaults->set_floor_freq (rd, mode);cpus_read_unlock ();
Re: [PATCH 5.15.y] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE bit cannot be changed
Quoted 75 lines · Harshit Mogalapalli
Hi Sasha,
Question inline from a backport point of view:
Quoted 70 lines · Sasha Levin
From: Zhang Rui <[email protected]>
[ Upstream commit
964209202ebe1569c858337441e87ef0f9d71416]PL1 cannot be disabled on some platforms. The ENABLE bit is still set
after software clears it. This behavior leads to a scenario where, upon
user request to disable the Power Limit through the powercap sysfs, the
ENABLE bit remains set while the CLAMPING bit is inadvertently cleared.According to the Intel Software Developer's Manual, the CLAMPING bit,
"When set, allows the processor to go below the OS requested P states in
order to maintain the power below specified Platform Power Limit value."Thus this means the system may operate at higher power levels than intended on such platforms.
Enhance the code to check ENABLE bit after writing to it, and stop further processing if ENABLE bit cannot be changed.
Reported-by: Srinivas Pandruvada
<[email protected]>Fixes 2d281d8196e3 ("PowerCap: Introduce Intel RAPL power cappingdriver")
Cc All applicable <[email protected]>Signed-off-by Zhang Rui <[email protected]>Link:
https://patch.msgid.link/[email protected]
[ rjw: Usestr_enabled_disabled()instead of open-coded equivalent ]Signed-off-by Rafael J. Wysocki <[email protected]>[ replaced
rapl_write_pl_data()andrapl_read_pl_data()withrapl_write_data_raw()andrapl_read_data_raw()]Signed-off-by Sasha Levin <[email protected]>---
drivers/powercap/intel_rapl_common.c| 23 ++++++++++++++++++++++-1 file changed, 22 insertions(+), 1 deletion(-)drivers/powercap/intel_rapl_common.c +0
-0@@ -212,12 +212,33 @@ static int find_nr_power_limit(struct rapl_domain *rd) static int set_domain_enable(struct powercap_zone *power_zone,bool mode) {struct
rapl_domain*rd =power_zone_to_rapl_domain(power_zone);drivers/powercap/intel_rapl_common.c +2
-0+u64 val; +int ret;
if (rd->state&DOMAIN_STATE_BIOS_LOCKED)
return-EACCES;
cpus_read_lock();drivers/powercap/intel_rapl_common.c +6
-1-rapl_write_data_raw (rd,PL1_ENABLE , mode); + ret =rapl_write_data_raw (rd,PL1_ENABLE , mode); +if (ret) { +cpus_read_unlock (); +return ret; + } +
Quoted 10 lines
drivers/powercap/intel_rapl_common.c static int find_nr_power_limit(struct rapl_domain *rd) · line 233
Quoted 6 lines
drivers/powercap/intel_rapl_common.c +6
-0+/* Check if the ENABLE bit was actually changed */ + ret =rapl_read_data_raw (rd,PL1_ENABLE , true, &val); +if (ret) { +cpus_read_unlock (); +return ret; + }Shouldn't this be
rapl_read_data_raw(rd, PL1_ENABLE, false, &val); ?
Correct. This will result in additional call to rapl_unit_xlate(), but since for primitive PL1_ENABLE, the unit is ARBITRARY_UNIT, this will not translate and return the same value.
Thanks,
Srinivas
Quoted 14 lines
Thanks
HarshitQuoted 11 lines
drivers/powercap/intel_rapl_common.c +8
-0+ +if (mode != val) { +pr_debug ("%s cannot be %s\n" , power_zone->name, + mode ?"enabled" :"disabled" ); +cpus_read_unlock (); +return 0 ; + } +if (
rapl_defaults->set_floor_freq)rapl_defaults->set_floor_freq(rd, mode);cpus_read_unlock();
Sasha Levin
maintainerRe: [PATCH 5.15.y] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE bit cannot be changed
Quoted 11 lines · srinivas pandruvada
Quoted 10 lines · Harshit Mogalapalli
drivers/powercap/intel_rapl_common.c static int find_nr_power_limit(struct rapl_domain *rd) · line 233
Quoted 6 lines
drivers/powercap/intel_rapl_common.c +6
-0+/* Check if the ENABLE bit was actually changed */ + ret =rapl_read_data_raw (rd,PL1_ENABLE , true, &val); +if (ret) { +cpus_read_unlock (); +return ret; + }Shouldn't this be
rapl_read_data_raw(rd, PL1_ENABLE, false, &val); ?
Quoted 3 lines
Correct. This will result in additional call to
rapl_unit_xlate(), but since for primitivePL1_ENABLE, the unit isARBITRARY_UNIT, this will not translate and return the same value.
I was thinking we need to call rapl_unit_xlate() so we won't just get whatever the raw value is, but yes - since it's ARBITRARY_UNIT then it won't really do much.
I guess in this case it doesn't really matter if we pass true or false here?
Signature · 2 lines
Thanks, Sasha
Re: [PATCH 5.15.y] powercap: intel_rapl: Do not change CLAMPING bit if ENABLE bit cannot be changed
Quoted 19 lines · Sasha Levin
Quoted 12 lines · srinivas pandruvada
Quoted 11 lines · Harshit Mogalapalli
drivers/powercap/intel_rapl_common.c static int find_nr_power_limit(struct rapl_domain *rd) · line 233
Quoted 6 lines
drivers/powercap/intel_rapl_common.c +6
-0+/* Check if the ENABLE bit was actually changed */ + ret =rapl_read_data_raw (rd,PL1_ENABLE , true, &val); +if (ret) { +cpus_read_unlock (); +return ret; + }Shouldn't this be
rapl_read_data_raw(rd, PL1_ENABLE, false, &val); ?Quoted 5 lines
Correct. This will result in additional call to
rapl_unit_xlate(), but
since for primitivePL1_ENABLE, the unit isARBITRARY_UNIT, this will
not translate and return the same value.
Quoted 8 lines
I was thinking we need to call
rapl_unit_xlate()so we won't just get whatever the raw value is, but yes - since it'sARBITRARY_UNITthen it
won't really do much.I guess in this case it doesn't really matter if we pass true or false
here?
correct, you just save one additional call.
Thanks,
Srinivas