cpufreq: Improve suspend-resume synchronization

The suspend-resume synchronization in the cpufreq core is not perfect
because the global cpufreq_suspended variable is set at the end of
cpufreq_suspend() after stopping governors for all of the active
policies, so the governor .limits() callback may run via
cpufreq_governor_limits() after stopping the governor and before
setting cpufreq_suspended which is questionable.  Likewise, the
governor .limits() callback may run between clearing cpufreq_suspended
in cpufreq_resume() and starting the governor.

Address this by adding a per-policy "suspended" flag that is always
read under the policy rwsem and is updated under it when the governor
is stopped in cpufreq_suspend() and when the governor is restarted in
cpufreq_resume().

Also make cpufreq_resume() use the cpus_read_lock guard to reflect
what is done in cpufreq_suspend() and call cpufreq_exit_governor() for
policies that were suspended during a system suspend transition and
are inactive during the subsequent system resume (to avoid leaking an
inactive policy with a stopped governor that has not exited yet).

Fixes: 8e30444e15 ("cpufreq: fix cpufreq suspend/resume for intel_pstate")
Fixes: b1b12babe3 ("cpufreq: update 'cpufreq_suspended' after stopping governors")
Cc: All applicable <[email protected]>
Signed-off-by: Rafael J. Wysocki <[email protected]>
Tested-by: Zak Brighton Knight <[email protected]>
Reviewed-by: Zhongqiu Han <[email protected]>
Acked-by: Viresh Kumar <[email protected]>
Tested-by: Doug Smythies <[email protected]>
Tested-by: Christian Loehle <[email protected]>
Link: https://patch.msgid.link/[email protected]
Signed-off-by: Rafael J. Wysocki <[email protected]>
This commit is contained in:
Rafael J. Wysocki
2026-11-04 15:07:01 +01:00
parent e6f50e602e
commit eee2a44e4e
2 changed files with 66 additions and 23 deletions
+63 -23
View File
@@ -35,6 +35,9 @@
static LIST_HEAD(cpufreq_policy_list);
/* Macros to iterate over CPU policies */
#define for_each_policy(__policy) \
list_for_each_entry(__policy, &cpufreq_policy_list, policy_list)
#define for_each_suitable_policy(__policy, __active) \
list_for_each_entry(__policy, &cpufreq_policy_list, policy_list) \
if ((__active) == !policy_is_inactive(__policy))
@@ -1960,6 +1963,14 @@ int cpufreq_generic_suspend(struct cpufreq_policy *policy)
}
EXPORT_SYMBOL(cpufreq_generic_suspend);
static void cpufreq_suspend_policy(struct cpufreq_policy *policy)
{
guard(cpufreq_policy_write)(policy);
cpufreq_stop_governor(policy);
policy->suspended = true;
}
/**
* cpufreq_suspend() - Suspend CPUFreq governors.
*
@@ -1982,11 +1993,8 @@ void cpufreq_suspend(void)
pr_debug("%s: Suspending Governors\n", __func__);
for_each_active_policy(policy) {
if (has_target()) {
scoped_guard(cpufreq_policy_write, policy) {
cpufreq_stop_governor(policy);
}
}
if (has_target())
cpufreq_suspend_policy(policy);
if (cpufreq_driver->suspend && cpufreq_driver->suspend(policy))
pr_err("%s: Failed to suspend driver: %s\n", __func__,
@@ -1998,6 +2006,32 @@ suspend:
cpus_read_unlock();
}
static void cpufreq_resume_policy(struct cpufreq_policy *policy, bool start)
{
guard(cpufreq_policy_write)(policy);
if (!policy->suspended)
return;
policy->suspended = false;
if (policy_is_inactive(policy)) {
/*
* The policy was active when it was suspended, so its governor
* is still there. Let the governor go.
*/
cpufreq_exit_governor(policy);
return;
}
if (!start)
return;
if (cpufreq_start_governor(policy))
pr_err("%s: Failed to start governor for CPU%u's policy\n",
__func__, policy->cpu);
}
/**
* cpufreq_resume() - Resume CPUFreq governors.
*
@@ -2007,11 +2041,12 @@ suspend:
void cpufreq_resume(void)
{
struct cpufreq_policy *policy;
int ret;
if (!cpufreq_driver)
return;
guard(cpus_read_lock)();
if (unlikely(!cpufreq_suspended))
return;
@@ -2022,19 +2057,18 @@ void cpufreq_resume(void)
pr_debug("%s: Resuming Governors\n", __func__);
for_each_active_policy(policy) {
if (cpufreq_driver->resume && cpufreq_driver->resume(policy)) {
pr_err("%s: Failed to resume driver: %s\n", __func__,
cpufreq_driver->name);
} else if (has_target()) {
scoped_guard(cpufreq_policy_write, policy) {
ret = cpufreq_start_governor(policy);
}
for_each_policy(policy) {
int ret = 0;
if (cpufreq_driver->resume && !policy_is_inactive(policy)) {
ret = cpufreq_driver->resume(policy);
if (ret)
pr_err("%s: Failed to start governor for CPU%u's policy\n",
__func__, policy->cpu);
pr_err("%s: Failed to resume driver: %s\n", __func__,
cpufreq_driver->name);
}
if (has_target())
cpufreq_resume_policy(policy, ret == 0);
}
}
@@ -2416,12 +2450,17 @@ __weak struct cpufreq_governor *cpufreq_fallback_governor(void)
return NULL;
}
static bool cpufreq_is_suspended(struct cpufreq_policy *policy)
{
return cpufreq_suspended || policy->suspended;
}
static int cpufreq_init_governor(struct cpufreq_policy *policy)
{
int ret;
/* Don't start any governor operations if we are entering suspend */
if (cpufreq_suspended)
/* Don't start any governor operations for suspended policies. */
if (cpufreq_is_suspended(policy))
return 0;
/*
* Governor might not be initiated here if ACPI _PPC changed
@@ -2464,7 +2503,7 @@ static int cpufreq_init_governor(struct cpufreq_policy *policy)
static void cpufreq_exit_governor(struct cpufreq_policy *policy)
{
if (cpufreq_suspended || !policy->governor)
if (cpufreq_is_suspended(policy) || !policy->governor)
return;
pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
@@ -2479,7 +2518,7 @@ int cpufreq_start_governor(struct cpufreq_policy *policy)
{
int ret;
if (cpufreq_suspended)
if (cpufreq_is_suspended(policy))
return 0;
if (!policy->governor)
@@ -2503,7 +2542,7 @@ int cpufreq_start_governor(struct cpufreq_policy *policy)
void cpufreq_stop_governor(struct cpufreq_policy *policy)
{
if (cpufreq_suspended || !policy->governor)
if (cpufreq_is_suspended(policy) || !policy->governor)
return;
pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
@@ -2514,7 +2553,7 @@ void cpufreq_stop_governor(struct cpufreq_policy *policy)
static void cpufreq_governor_limits(struct cpufreq_policy *policy)
{
if (cpufreq_suspended || !policy->governor)
if (cpufreq_is_suspended(policy) || !policy->governor)
return;
pr_debug("%s: for CPU %u\n", __func__, policy->cpu);
@@ -2751,7 +2790,8 @@ static void cpufreq_policy_refresh(struct cpufreq_policy *policy)
* -> ask driver for current freq and notify governors about a change
*/
if (cpufreq_driver->get && has_target() &&
(cpufreq_suspended || WARN_ON(!cpufreq_verify_current_freq(policy, false))))
(cpufreq_is_suspended(policy) ||
WARN_ON(!cpufreq_verify_current_freq(policy, false))))
return;
refresh_frequency_limits(policy);
+3
View File
@@ -149,6 +149,9 @@ struct cpufreq_policy {
/* Pending policy->min/max update for the driver */
bool update_limits;
/* The policy has been suspended. */
bool suspended;
/* Cached frequency lookup from cpufreq_driver_resolve_freq. */
unsigned int cached_target_freq;
unsigned int cached_resolved_idx;