Re: [PATCH 6/7] virt: steal_governor: restart sampling immediately after CPU hotplug
From: Shrikanth Hegde
Date: Thu Nov 19 2026 - 01:07:45 EST
Hi Yury.
On 11/14/26 12:12 AM, Yury Norov wrote:
CPU hotplug between samples can distort the calculated steal ratio because
the governor divides accumulated steal time by the current active CPU
count, even when that count changed during the sampling interval.
For example, assume a constant 3% steal rate on each CPU, with four active
CPUs for 900ms followed by two active CPUs for 100ms. The accumulated
steal time is:
4 * 900ms * 3% + 2 * 100ms * 3% = 108ms + 6ms = 114ms
This example is not realistic. If you had 3% steal with 4 CPUs, and if they become 2,
your steal time will definitely increase. It will likely double. So
governor likely calculates 6%.
But yes, you can have realistic examples, where governor may calculate
the values which goes slightly above or below. But IMHO those examples are very
limited. Even in the above examples, the steal governor was supposed to trigger
high threshold since the steal time with 2 CPUs is 6%. So if not now, in the next
delta it would have triggered it anyways.
Some examples are really corner cases. Maybe like
60 CPUs 3% steal, and then 40 CPUs 5.1% steal = 4.55%
(Below threshold, but should have been high). One interval missed. But if you see
large duration was in low threshold, so it is agreeable to miss it.
The elapsed time is 1000ms. Using the final count of two active CPUs, the
governor calculates:
114ms / (2 * 1000ms) = 5.7%
This exceeds the default 5% high threshold, even though the actual steal
rate stayed at 3%. Using the CPU counts over the whole interval gives:
114ms / (4 * 900ms + 2 * 100ms) = 3%
Checking num_online_cpus() doesn't account for cases where CPUs go online
and offline such that the total number of online CPUs doesn't change. So,
implement the sampling restart on hotplug event.
I am not sure if we really need to stress about hotplug cases. IIUC, when a user
does hotplug, systems are usually idle. (Atleast that is what we have observed in
real life use cases). And hotplug is really user driven, so user knows system is going
through some transitions and will be stable soon.
Fixes: 27d47ebce4d6 ("virt/steal_governor: Implement steal_governor policy loop")
Signed-off-by: Yury Norov <ynorov@xxxxxxxxxx>
---
drivers/virt/steal_governor.c | 37 ++++++++++++++++++++++++++++++++---
1 file changed, 34 insertions(+), 3 deletions(-)
diff --git a/drivers/virt/steal_governor.c b/drivers/virt/steal_governor.c
index c34d91267ec1..f71dbf27e4a9 100644
--- a/drivers/virt/steal_governor.c
+++ b/drivers/virt/steal_governor.c
@@ -14,6 +14,7 @@
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/cleanup.h>
+#include <linux/cpuhotplug.h>
#include <linux/cpuhplock.h>
#include <linux/cpumask.h>
#include <linux/init.h>
@@ -42,6 +43,8 @@ struct steal_governor {
unsigned long delay;
unsigned int high_threshold;
unsigned int low_threshold;
+ int hp_state;
+ bool sample_invalidated;
struct delayed_work work;
};
@@ -217,6 +220,13 @@ static bool preferred_cpus_valid(void)
return true;
}
+static int hotplug_callback(unsigned int cpu)
+{
+ sg_ctx.sample_invalidated = true;
+ mod_delayed_work(system_wq, &sg_ctx.work, 0);
+ return 0;
+}
+
static void steal_governor_loop(struct work_struct *work)
{
u64 curr_steal, delta_steal, delta_ns, steal_ratio;
@@ -233,6 +243,11 @@ static void steal_governor_loop(struct work_struct *work)
sg_ctx.steal = curr_steal;
sg_ctx.time = now;
+ if (sg_ctx.sample_invalidated) {
+ sg_ctx.sample_invalidated = false;
+ goto requeue_work;
+ }
+
/*
* steal_ratio = (delta_steal * 100*100)/(delta_ns * num_cpus())
* To avoid possible overflow, divide the denominator early.
@@ -254,11 +269,14 @@ static void steal_governor_loop(struct work_struct *work)
return;
}
- schedule_delayed_work(&sg_ctx.work, sg_ctx.delay);
+requeue_work:
+ mod_delayed_work(system_wq, &sg_ctx.work, sg_ctx.delay);
}
static int __init steal_governor_init(void)
{
+ int ret;
+
#ifdef CONFIG_XEN
if (xen_initial_domain()) {
pr_err("Cannot load in Xen Dom0 (Host OS). Driver is for guests only.\n");
@@ -273,8 +291,20 @@ static int __init steal_governor_init(void)
}
INIT_DELAYED_WORK(&sg_ctx.work, steal_governor_loop);
- sg_ctx.steal = get_system_steal_time();
- sg_ctx.time = ktime_get();
+ /* Lock to prevent unobserved hotplug event during setup. */
+ scoped_guard(cpus_read_lock) {
+ sg_ctx.steal = get_system_steal_time();
+ sg_ctx.time = ktime_get();
+ sg_ctx.sample_invalidated = false;
+ ret = cpuhp_setup_state_nocalls_cpuslocked(CPUHP_AP_ONLINE_DYN,
+ "virt/steal_governor:online",
+ hotplug_callback,
+ hotplug_callback);
+ }
+ if (ret < 0)
+ return ret;
+ sg_ctx.hp_state = ret;
+
schedule_delayed_work(&sg_ctx.work, sg_ctx.delay);
pr_info("enabled. interval: %ums, high_threshold: %u, low_threshold: %u\n",
jiffies_to_msecs(sg_ctx.delay), sg_ctx.high_threshold, sg_ctx.low_threshold);
@@ -285,6 +315,7 @@ static int __init steal_governor_init(void)
static void __exit steal_governor_exit(void)
{
disable_delayed_work_sync(&sg_ctx.work);
+ cpuhp_remove_state_nocalls(sg_ctx.hp_state);
guard(cpus_read_lock)();
guard(mutex)(&cpu_preferred_mutex);