Skip to contentSkip to conversation

cpuidle: Consolidate disabled state checks

PATCH In review Rafael J. Wysocki 4 participants 8 messages Nov 4, 2019 – Nov 18, 2019

Subsystems (5)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 cpuidle: Consolidate disabled state checks

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively). In the latter case, the "disable" field of the given state's cpuidle_state_usage struct is set and it may be changed via sysfs. Thus checking whether or not an idle state has been disabled involves reading these two flags every time.

In order to avoid the additional check of the state's "disabled" flag (which is effectively read-only anyway), use the value of it at the init time to set a (new) flag in the "disable" field of that state's cpuidle_state_usage structure and use the sysfs interface to manipulate another (new) flag in it. This way the state is disabled whenever the "disable" field of its cpuidle_state_usage structure is nonzero, whatever the reason, and it is the only place to look into to check whether or not the state has been disabled.

---

Changes since RFC:
- Make show_disable_state() only show the "user" bit (for compatibility with the existing behavior).
- Add a tag from Daniel.

---
 drivers/cpuidle/cpuidle-powernv.c  |    7 +----
 drivers/cpuidle/cpuidle.c          |   24 +++++++++--------
 drivers/cpuidle/governors/ladder.c |    4 --
 drivers/cpuidle/governors/menu.c   |    8 ++---
 drivers/cpuidle/governors/teo.c    |    5 +--
 drivers/cpuidle/sysfs.c            |   51 +++++++++++++++++++++----------------
 include/linux/cpuidle.h            |    3 ++
 7 files changed, 54 insertions(+), 48 deletions(-)
drivers/cpuidle/cpuidle.c +13 -11
Index: linux-pm/drivers/cpuidle/cpuidle.c
===================================================================
@@ -84,12 +84,12 @@ static int find_deepest_state(struct cpu
 
 	for (i = 1; i < drv->state_count; i++) {
 		struct cpuidle_state *s = &drv->states[i];
-		struct cpuidle_state_usage *su = &dev->states_usage[i];
 
-		if (s->disabled || su->disable || s->exit_latency <= latency_req
-		    || s->exit_latency > max_latency
-		    || (s->flags & forbidden_flags)
-		    || (s2idle && !s->enter_s2idle))
+		if (dev->states_usage[i].disable ||
+		    s->exit_latency <= latency_req ||
+		    s->exit_latency > max_latency ||
+		    (s->flags & forbidden_flags) ||
+		    (s2idle && !s->enter_s2idle))
 			continue;
 
 		latency_req = s->exit_latency;
@@ -265,8 +265,7 @@ int cpuidle_enter_state(struct cpuidle_d
 
 		if (diff < drv->states[entered_state].target_residency) {
 			for (i = entered_state - 1; i >= 0; i--) {
-				if (drv->states[i].disabled ||
-				    dev->states_usage[i].disable)
+				if (dev->states_usage[i].disable)
 					continue;
 
 				/* Shallower states are enabled, so update. */
@@ -275,8 +274,7 @@ int cpuidle_enter_state(struct cpuidle_d
 			}
 		} else if (diff > delay) {
 			for (i = entered_state + 1; i < drv->state_count; i++) {
-				if (drv->states[i].disabled ||
-				    dev->states_usage[i].disable)
+				if (dev->states_usage[i].disable)
 					continue;
 
 				/*
@@ -380,7 +378,7 @@ u64 cpuidle_poll_time(struct cpuidle_dri
 
 	limit_ns = TICK_NSEC;
 	for (i = 1; i < drv->state_count; i++) {
-		if (drv->states[i].disabled || dev->states_usage[i].disable)
+		if (dev->states_usage[i].disable)
 			continue;
 
 		limit_ns = (u64)drv->states[i].target_residency * NSEC_PER_USEC;
@@ -567,12 +565,16 @@ static void __cpuidle_device_init(struct
  */
 static int __cpuidle_register_device(struct cpuidle_device *dev)
 {
-	int ret;
 	struct cpuidle_driver *drv = cpuidle_get_cpu_driver(dev);
+	int i, ret;
 
 	if (!try_module_get(drv->owner))
 		return -EINVAL;
 
+	for (i = 0; i < drv->state_count; i++)
+		if (drv->states[i].disabled)
+			dev->states_usage[i].disable |= CPUIDLE_STATE_DISABLED_BY_DRIVER;
+
 	per_cpu(cpuidle_devices, dev->cpu) = dev;
 	list_add(&dev->device_list, &cpuidle_detected_devices);
 
drivers/cpuidle/sysfs.c +30 -21

66 lines not on this page · raw message

include/linux/cpuidle.h +3 -0
Index: linux-pm/include/linux/cpuidle.h
===================================================================
@@ -29,6 +29,9 @@ struct cpuidle_driver;
  * CPUIDLE DEVICE INTERFACE *
  ****************************/
 
+#define CPUIDLE_STATE_DISABLED_BY_USER		BIT(0)
+#define CPUIDLE_STATE_DISABLED_BY_DRIVER	BIT(1)
+
 struct cpuidle_state_usage {
 	unsigned long long	disable;
 	unsigned long long	usage;
drivers/cpuidle/governors/menu.c +3 -5
Index: linux-pm/drivers/cpuidle/governors/menu.c
===================================================================
@@ -298,7 +298,7 @@ static int menu_select(struct cpuidle_dr
 	if (unlikely(drv->state_count <= 1 || latency_req == 0) ||
 	    ((data->next_timer_us < drv->states[1].target_residency ||
 	      latency_req < drv->states[1].exit_latency) &&
-	     !drv->states[0].disabled && !dev->states_usage[0].disable)) {
+	     !dev->states_usage[0].disable)) {
 		/*
 		 * In this case state[0] will be used no matter what, so return
 		 * it right away and keep the tick running if state[0] is a
@@ -349,9 +349,8 @@ static int menu_select(struct cpuidle_dr
 	idx = -1;
 	for (i = 0; i < drv->state_count; i++) {
 		struct cpuidle_state *s = &drv->states[i];
-		struct cpuidle_state_usage *su = &dev->states_usage[i];
 
-		if (s->disabled || su->disable)
+		if (dev->states_usage[i].disable)
 			continue;
 
 		if (idx == -1)
@@ -422,8 +421,7 @@ static int menu_select(struct cpuidle_dr
 			 * tick, so try to correct that.
 			 */
 			for (i = idx - 1; i >= 0; i--) {
-				if (drv->states[i].disabled ||
-				    dev->states_usage[i].disable)
+				if (dev->states_usage[i].disable)
 					continue;
 
 				idx = i;
drivers/cpuidle/governors/teo.c +2 -3
Index: linux-pm/drivers/cpuidle/governors/teo.c
===================================================================
@@ -212,7 +212,7 @@ static int teo_find_shallower_state(stru
 	int i;
 
 	for (i = state_idx - 1; i >= 0; i--) {
-		if (drv->states[i].disabled || dev->states_usage[i].disable)
+		if (dev->states_usage[i].disable)
 			continue;
 
 		state_idx = i;
@@ -254,9 +254,8 @@ static int teo_select(struct cpuidle_dri
 
 	for (i = 0; i < drv->state_count; i++) {
 		struct cpuidle_state *s = &drv->states[i];
-		struct cpuidle_state_usage *su = &dev->states_usage[i];
 
-		if (s->disabled || su->disable) {
+		if (dev->states_usage[i].disable) {
 			/*
 			 * If the "early hits" metric of a disabled state is
 			 * greater than the current maximum, it should be taken
drivers/cpuidle/governors/ladder.c +1 -3
Index: linux-pm/drivers/cpuidle/governors/ladder.c
===================================================================
@@ -84,7 +84,6 @@ static int ladder_select_state(struct cp
 
 	/* consider promotion */
 	if (last_idx < drv->state_count - 1 &&
-	    !drv->states[last_idx + 1].disabled &&
 	    !dev->states_usage[last_idx + 1].disable &&
 	    last_residency > last_state->threshold.promotion_time &&
 	    drv->states[last_idx + 1].exit_latency <= latency_req) {
@@ -98,8 +97,7 @@ static int ladder_select_state(struct cp
 
 	/* consider demotion */
 	if (last_idx > first_idx &&
-	    (drv->states[last_idx].disabled ||
-	    dev->states_usage[last_idx].disable ||
+	    (dev->states_usage[last_idx].disable ||
 	    drv->states[last_idx].exit_latency > latency_req)) {
 		int i;
 
drivers/cpuidle/cpuidle-powernv.c +2 -5
Index: linux-pm/drivers/cpuidle/cpuidle-powernv.c
===================================================================
@@ -56,13 +56,10 @@ static u64 get_snooze_timeout(struct cpu
 		return default_snooze_timeout;
 
 	for (i = index + 1; i < drv->state_count; i++) {
-		struct cpuidle_state *s = &drv->states[i];
-		struct cpuidle_state_usage *su = &dev->states_usage[i];
-
-		if (s->disabled || su->disable)
+		if (dev->states_usage[i].disable)
 			continue;
 
-		return s->target_residency * tb_ticks_per_usec;
+		return drv->states[i].target_residency * tb_ticks_per_usec;
 	}
 
 	return default_snooze_timeout;
Acked-by on v1 1/1
#1 lore raw
Quoted 22 lines · Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively). In the latter case, the "disable" field of the given state's cpuidle_state_usage struct is set and it may be changed via sysfs. Thus checking whether or not an idle state has been disabled involves reading these two flags every time.

In order to avoid the additional check of the state's "disabled" flag (which is effectively read-only anyway), use the value of it at the init time to set a (new) flag in the "disable" field of that state's cpuidle_state_usage structure and use the sysfs interface to manipulate another (new) flag in it. This way the state is disabled whenever the "disable" field of its cpuidle_state_usage structure is nonzero, whatever the reason, and it is the only place to look into to check whether or not the state has been disabled.

Quoted 2 lines

Much thanks, that always bugged me.

reviewer
#2 lore raw
In reply to Rafael J. Wysocki
Quoted 10 lines · Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively).

for x86 (intel_idle and acpi_idle), no states with disabled=1 are registered with cpuidle. Instead, intel_idle (currently) skips them in the loop that registers states.
(and acpi_idle never touches the disabled field)

And so for x86, governors checking for drv->states[i].disabled is a NOP, and the condition described by CPUIDLE_STATE_DISABLED_BY_DRIVER does not (yet) exist.

Looking at the ARM code, it seems that cpuidle-imx6q.c and cpuidle-tegra20.c reach into the cpuidle states at run time and toggle the drv->states[i].disabled.

It seems that this patch takes the initial value of drv->states->disabled, and sets the (per cpu) usage.disable=..BY_DRIVER,
but that subsequent run-time toggles in drv->states[i]disabled by these drivers would be missed,
because you're removed the run-time checking of drv->states->disabled?

Finally, I'd like to change intel_idle so that it *can* register a state that is disabled, by default.
If I change the driver to NOT skip registering disabled states, and the cpuidle copy has cpuidle_state.disabled=1,
then the state is indeed, unused at run-time. But as you said, it is effectively read-only, and is not indicated in sysfs, and can not be changed via sysfs.

One way to do this is to do what you do here and initialize usage.disabled to drv->state.disabled. (not distinguishing between DRIVER and USER)
That way the user could later over-ride what a driver set, by clearing the disabled attribute.

However, the ARM drivers, at least, seem to want to reserve the right to set and clear the drv->state.disabled,
and to have them continue to have that right, we have to continue checking that field at run-time.
And giving drivers the opportunity to do that disabling driver-wide, instead of per-cpu (usage) wide,
seems to be something we may want to keep.

-Len

Signature · 1 line
Len Brown, Intel Open Source Technology Center
#3 lore raw
Quoted 13 lines · Len Brown
Quoted 10 lines · Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively).

Quoted 8 lines

for x86 (intel_idle and acpi_idle), no states with disabled=1 are registered with cpuidle. Instead, intel_idle (currently) skips them in the loop that registers states.
(and acpi_idle never touches the disabled field)

And so for x86, governors checking for drv->states[i].disabled is a NOP, and the condition described by CPUIDLE_STATE_DISABLED_BY_DRIVER does not (yet) exist.

OK

Quoted 3 lines

Looking at the ARM code, it seems that cpuidle-imx6q.c and cpuidle-tegra20.c reach into the cpuidle states at run time and toggle the drv->states[i].disabled.

I might have overlooked that, let me check.

Quoted 6 lines

It seems that this patch takes the initial value of drv->states->disabled, and sets the (per cpu) usage.disable=..BY_DRIVER,
but that subsequent run-time toggles in drv->states[i]disabled by these drivers would be missed,
because you're removed the run-time checking of drv->states->disabled?

If it is updated at run time, then yes, the updates will be missed, so thanks for pointing that out.

Quoted 14 lines

Finally, I'd like to change intel_idle so that it *can* register a state that is disabled, by default.
If I change the driver to NOT skip registering disabled states, and the cpuidle copy has cpuidle_state.disabled=1,
then the state is indeed, unused at run-time. But as you said, it is effectively read-only, and is not indicated in sysfs, and can not be changed via sysfs.

One way to do this is to do what you do here and initialize usage.disabled to drv->state.disabled. (not distinguishing between DRIVER and USER)
That way the user could later over-ride what a driver set, by clearing the disabled attribute.

Quoted 4 lines

However, the ARM drivers, at least, seem to want to reserve the right to set and clear the drv->state.disabled,
and to have them continue to have that right, we have to continue checking that field at run-time.

Alternatively, the drivers in question can be changed to update the disable field in state_usage instead (maybe under a lock to prevent them from racing with user space).

Quoted 3 lines

And giving drivers the opportunity to do that disabling driver-wide, instead of per-cpu (usage) wide,
seems to be something we may want to keep.

So it looks like you want me to revert this patch which is something that I really don't want to do, because of the extra checks all over the place which are simply pointless in the majority of cases.

Cheers,
Rafael

#4 lore raw
Quoted 39 lines · Rafael J. Wysocki
Quoted 13 lines · Len Brown
Quoted 10 lines · Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively).

Quoted 8 lines

for x86 (intel_idle and acpi_idle), no states with disabled=1 are registered with cpuidle. Instead, intel_idle (currently) skips them in the loop that registers states.
(and acpi_idle never touches the disabled field)

And so for x86, governors checking for drv->states[i].disabled is a NOP, and the condition described by CPUIDLE_STATE_DISABLED_BY_DRIVER does not (yet) exist.

OK

Quoted 3 lines

Looking at the ARM code, it seems that cpuidle-imx6q.c and cpuidle-tegra20.c reach into the cpuidle states at run time and toggle the drv->states[i].disabled.

I might have overlooked that, let me check.

Quoted 6 lines

It seems that this patch takes the initial value of drv->states->disabled, and sets the (per cpu) usage.disable=..BY_DRIVER,
but that subsequent run-time toggles in drv->states[i]disabled by these drivers would be missed,
because you're removed the run-time checking of drv->states->disabled?

Quoted 16 lines

If it is updated at run time, then yes, the updates will be missed, so thanks for pointing that out.

Quoted 13 lines

Finally, I'd like to change intel_idle so that it *can* register a state that is disabled, by default.
If I change the driver to NOT skip registering disabled states, and the cpuidle copy has cpuidle_state.disabled=1,
then the state is indeed, unused at run-time. But as you said, it is effectively read-only, and is not indicated in sysfs, and can not be changed via sysfs.

One way to do this is to do what you do here and initialize usage.disabled to drv->state.disabled. (not distinguishing between DRIVER and USER)
That way the user could later over-ride what a driver set, by clearing the disabled attribute.

I'd rather get rid of the "disabled" field from struct cpuidle_state entirely and introduce a new state flag to indicate the "disabled by default" status.

I also would expose that new flag in a new sysfs attribute of idle states, say "disable_default".

Then, the DISABLED_BY_DRIVER bit would be reserved for driver quirks (as per https://patchwork.kernel.org/patch/11249519/) and the DISABLED_BY_USER one could be used for all of the other purposes.

Cheers,
Rafael

#5 lore raw

cover cpuidle: Allow states to be disabled by default (was: Re: [PATCH] cpuidle: Consolidate disabled state checks)

Quoted 61 lines · CET Rafael J. Wysocki
Quoted 39 lines · Rafael J. Wysocki
Quoted 13 lines · Len Brown
Quoted 10 lines · Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

There are two reasons why CPU idle states may be disabled: either because the driver has disabled them or because they have been disabled by user space via sysfs.

In the former case, the state's "disabled" flag is set once during the initialization of the driver and it is never cleared later (it is read-only effectively).

Quoted 8 lines

for x86 (intel_idle and acpi_idle), no states with disabled=1 are registered with cpuidle. Instead, intel_idle (currently) skips them in the loop that registers states.
(and acpi_idle never touches the disabled field)

And so for x86, governors checking for drv->states[i].disabled is a NOP, and the condition described by CPUIDLE_STATE_DISABLED_BY_DRIVER does not (yet) exist.

OK

Quoted 3 lines

Looking at the ARM code, it seems that cpuidle-imx6q.c and cpuidle-tegra20.c reach into the cpuidle states at run time and toggle the drv->states[i].disabled.

I might have overlooked that, let me check.

Quoted 6 lines

It seems that this patch takes the initial value of drv->states->disabled, and sets the (per cpu) usage.disable=..BY_DRIVER,
but that subsequent run-time toggles in drv->states[i]disabled by these drivers would be missed,
because you're removed the run-time checking of drv->states->disabled?

Quoted 16 lines

If it is updated at run time, then yes, the updates will be missed, so thanks for pointing that out.

Quoted 13 lines

Finally, I'd like to change intel_idle so that it *can* register a state that is disabled, by default.
If I change the driver to NOT skip registering disabled states, and the cpuidle copy has cpuidle_state.disabled=1,
then the state is indeed, unused at run-time. But as you said, it is effectively read-only, and is not indicated in sysfs, and can not be changed via sysfs.

One way to do this is to do what you do here and initialize usage.disabled to drv->state.disabled. (not distinguishing between DRIVER and USER)
That way the user could later over-ride what a driver set, by clearing the disabled attribute.

I'd rather get rid of the "disabled" field from struct cpuidle_state entirely and introduce a new state flag to indicate the "disabled by default" status.

Quoted 6 lines

I also would expose that new flag in a new sysfs attribute of idle states, say "disable_default".

Then, the DISABLED_BY_DRIVER bit would be reserved for driver quirks (as per https://patchwork.kernel.org/patch/11249519/) and the DISABLED_BY_USER one could be used for all of the other purposes.

To that end, I have the following two experimental patches (on top of
https://patchwork.kernel.org/patch/11249519/) that IMO are simple enough.

Please let me know what you think.

#6 lore raw

RFC PATCH 1/2 cpuidle: Drop disabled field from struct cpuidle_state

From: Rafael J. Wysocki <[email protected]>

After recent cpuidle updates the disabled field in struct cpuidle_state is only used by two drivers (intel_idle and shmobile cpuidle) for marking unusable idle states, but that may as well be achieved with the help of a state flag, so define an "unusable" idle state flag, CPUIDLE_FLAG_UNUSABLE, make the drivers in question use it instead of the disable field and make the core set CPUIDLE_STATE_DISABLED_BY_DRIVER for the idle states with that flag set.

After the above changes, the disabled field in struct cpuidle_state is not used any more, so drop it.

No intentional functional impact.

---
 arch/sh/kernel/cpu/shmobile/cpuidle.c |    8 ++++----
 drivers/cpuidle/cpuidle.c             |    2 +-
 drivers/cpuidle/poll_state.c          |    1 -
 drivers/idle/intel_idle.c             |    6 +++---
 include/linux/cpuidle.h               |    2 +-
 5 files changed, 9 insertions(+), 10 deletions(-)
drivers/idle/intel_idle.c +3 -3
Index: linux-pm/drivers/idle/intel_idle.c
===================================================================
@@ -1291,8 +1291,8 @@ static void sklh_idle_state_table_update
 			return;
 	}
 
-	skl_cstates[5].disabled = 1;	/* C8-SKL */
-	skl_cstates[6].disabled = 1;	/* C9-SKL */
+	skl_cstates[5].flags |= CPUIDLE_FLAG_UNUSABLE;	/* C8-SKL */
+	skl_cstates[6].flags |= CPUIDLE_FLAG_UNUSABLE;	/* C9-SKL */
 }
 /*
  * intel_idle_state_table_update()
@@ -1355,7 +1355,7 @@ static void __init intel_idle_cpuidle_dr
 			continue;
 
 		/* if state marked as disabled, skip it */
-		if (cpuidle_state_table[cstate].disabled != 0) {
+		if (cpuidle_state_table[cstate].flags & CPUIDLE_FLAG_UNUSABLE) {
 			pr_debug("state %s is disabled\n",
 				 cpuidle_state_table[cstate].name);
 			continue;
include/linux/cpuidle.h +1 -1
Index: linux-pm/include/linux/cpuidle.h
===================================================================
@@ -54,7 +54,6 @@ struct cpuidle_state {
 	unsigned int	exit_latency; /* in US */
 	int		power_usage; /* in mW */
 	unsigned int	target_residency; /* in US */
-	bool		disabled; /* disabled on all CPUs */
 
 	int (*enter)	(struct cpuidle_device *dev,
 			struct cpuidle_driver *drv,
@@ -77,6 +76,7 @@ struct cpuidle_state {
 #define CPUIDLE_FLAG_POLLING	BIT(0) /* polling state */
 #define CPUIDLE_FLAG_COUPLED	BIT(1) /* state applies to multiple cpus */
 #define CPUIDLE_FLAG_TIMER_STOP BIT(2) /* timer is stopped on this state */
+#define CPUIDLE_FLAG_UNUSABLE	BIT(3) /* avoid using this state */
 
 struct cpuidle_device_kobj;
 struct cpuidle_state_kobj;
arch/sh/kernel/cpu/shmobile/cpuidle.c +4 -4
Index: linux-pm/arch/sh/kernel/cpu/shmobile/cpuidle.c
===================================================================
@@ -67,7 +67,7 @@ static struct cpuidle_driver cpuidle_dri
 			.enter = cpuidle_sleep_enter,
 			.name = "C2",
 			.desc = "SuperH Sleep Mode [SF]",
-			.disabled = true,
+			.flags = CPUIDLE_FLAG_UNUSABLE,
 		},
 		{
 			.exit_latency = 2300,
@@ -76,7 +76,7 @@ static struct cpuidle_driver cpuidle_dri
 			.enter = cpuidle_sleep_enter,
 			.name = "C3",
 			.desc = "SuperH Mobile Standby Mode [SF]",
-			.disabled = true,
+			.flags = CPUIDLE_FLAG_UNUSABLE,
 		},
 	},
 	.safe_state_index = 0,
@@ -86,10 +86,10 @@ static struct cpuidle_driver cpuidle_dri
 int __init sh_mobile_setup_cpuidle(void)
 {
 	if (sh_mobile_sleep_supported & SUSP_SH_SF)
-		cpuidle_driver.states[1].disabled = false;
+		cpuidle_driver.states[1].flags = CPUIDLE_FLAG_NONE;
 
 	if (sh_mobile_sleep_supported & SUSP_SH_STANDBY)
-		cpuidle_driver.states[2].disabled = false;
+		cpuidle_driver.states[2].flags = CPUIDLE_FLAG_NONE;
 
 	return cpuidle_register(&cpuidle_driver, NULL);
 }
drivers/cpuidle/cpuidle.c +1 -1
Index: linux-pm/drivers/cpuidle/cpuidle.c
===================================================================
@@ -570,7 +570,7 @@ static int __cpuidle_register_device(str
 		return -EINVAL;
 
 	for (i = 0; i < drv->state_count; i++)
-		if (drv->states[i].disabled)
+		if (drv->states[i].flags & CPUIDLE_FLAG_UNUSABLE)
 			dev->states_usage[i].disable |= CPUIDLE_STATE_DISABLED_BY_DRIVER;
 
 	per_cpu(cpuidle_devices, dev->cpu) = dev;
drivers/cpuidle/poll_state.c +0 -1
Index: linux-pm/drivers/cpuidle/poll_state.c
===================================================================
@@ -53,7 +53,6 @@ void cpuidle_poll_state_init(struct cpui
 	state->target_residency_ns = 0;
 	state->power_usage = -1;
 	state->enter = poll_idle;
-	state->disabled = false;
 	state->flags = CPUIDLE_FLAG_POLLING;
 }
 EXPORT_SYMBOL_GPL(cpuidle_poll_state_init);
#7 lore raw

RFC PATCH 2/2 cpuidle: Allow idle states to be disabled by default

In reply to Rafael J. Wysocki

From: Rafael J. Wysocki <[email protected]>

In certain situations it may be useful to prevent some idle states from being used by default while allowing user space to enable them later on.

For this purpose, introduce a new state flag, CPUIDLE_FLAG_UNCERTAIN, to mark idle states that should be disabled by default, make the core set CPUIDLE_STATE_DISABLED_BY_USER for those states at the initialization time and add a new state attribute in sysfs, "disable_default", to provide user space with the default value of the "disable" attribute (1 if CPUIDLE_FLAG_UNCERTAIN is set for the given state, 0 otherwise) to allow it to restore the initial configuration of idle states easily if need be.

---
 Documentation/ABI/testing/sysfs-devices-system-cpu |    6 ++++++
 Documentation/admin-guide/pm/cpuidle.rst           |    3 +++
 drivers/cpuidle/cpuidle.c                          |    3 +++
 drivers/cpuidle/sysfs.c                            |    9 +++++++++
 include/linux/cpuidle.h                            |    1 +
 5 files changed, 22 insertions(+)
drivers/cpuidle/sysfs.c +9 -0
Index: linux-pm/drivers/cpuidle/sysfs.c
===================================================================
@@ -327,6 +327,13 @@ static ssize_t store_state_disable(struc
 	return size;
 }
 
+static ssize_t show_state_disable_default(struct cpuidle_state *state,
+					  struct cpuidle_state_usage *state_usage,
+					  char *buf)
+{
+	return sprintf(buf, "%u\n", !!(state->flags & CPUIDLE_FLAG_UNCERTAIN));
+}
+
 define_one_state_ro(name, show_state_name);
 define_one_state_ro(desc, show_state_desc);
 define_one_state_ro(latency, show_state_exit_latency);
@@ -337,6 +344,7 @@ define_one_state_ro(time, show_state_tim
 define_one_state_rw(disable, show_state_disable, store_state_disable);
 define_one_state_ro(above, show_state_above);
 define_one_state_ro(below, show_state_below);
+define_one_state_ro(disable_default, show_state_disable_default);
 
 static struct attribute *cpuidle_state_default_attrs[] = {
 	&attr_name.attr,
@@ -347,6 +355,7 @@ static struct attribute *cpuidle_state_d
 	&attr_usage.attr,
 	&attr_time.attr,
 	&attr_disable.attr,
+	&attr_disable_default.attr,
 	&attr_above.attr,
 	&attr_below.attr,
 	NULL
include/linux/cpuidle.h +1 -0
Index: linux-pm/include/linux/cpuidle.h
===================================================================
@@ -77,6 +77,7 @@ struct cpuidle_state {
 #define CPUIDLE_FLAG_COUPLED	BIT(1) /* state applies to multiple cpus */
 #define CPUIDLE_FLAG_TIMER_STOP BIT(2) /* timer is stopped on this state */
 #define CPUIDLE_FLAG_UNUSABLE	BIT(3) /* avoid using this state */
+#define CPUIDLE_FLAG_UNCERTAIN	BIT(4) /* disable this state by default */
 
 struct cpuidle_device_kobj;
 struct cpuidle_state_kobj;
drivers/cpuidle/cpuidle.c +3 -0
Index: linux-pm/drivers/cpuidle/cpuidle.c
===================================================================
@@ -572,6 +572,9 @@ static int __cpuidle_register_device(str
 	for (i = 0; i < drv->state_count; i++) {
 		if (drv->states[i].flags & CPUIDLE_FLAG_UNUSABLE)
 			dev->states_usage[i].disable |= CPUIDLE_STATE_DISABLED_BY_DRIVER;
+
+		if (drv->states[i].flags & CPUIDLE_FLAG_UNCERTAIN)
+			dev->states_usage[i].disable |= CPUIDLE_STATE_DISABLED_BY_USER;
 	}
 
 	per_cpu(cpuidle_devices, dev->cpu) = dev;
Documentation/ABI/testing/sysfs-devices-system-cpu +6 -0
Index: linux-pm/Documentation/ABI/testing/sysfs-devices-system-cpu
===================================================================
@@ -196,6 +196,12 @@ Description:
 		does not reflect it. Likewise, if one enables a deep state but a
 		lighter state still is disabled, then this has no effect.
 
+What:		/sys/devices/system/cpu/cpuX/cpuidle/stateN/disable_dafault
+Date:		November 2019
+KernelVersion:	v5.4
+Contact:	Linux power management list <[email protected]>
+Description:
+		(RO) The default value of the disable state attribute (bool).
 
 What:		/sys/devices/system/cpu/cpuX/cpuidle/stateN/residency
 Date:		March 2014
Documentation/admin-guide/pm/cpuidle.rst +3 -0
Index: linux-pm/Documentation/admin-guide/pm/cpuidle.rst
===================================================================
@@ -506,6 +506,9 @@ object corresponding to it, as follows:
 ``disable``
 	Whether or not this idle state is disabled.
 
+``disable_default``
+	The default value of the ``disable`` attribute.
+
 ``latency``
 	Exit latency of the idle state in microseconds.