4 files changed, 42 insertions, 0 deletions

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 7f1da77b83f3..699ff1499a8a 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -6024,6 +6024,7 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
                 return;
 
         update_group_power(sd, cpu);
+        atomic_set(&sg->sgp->nr_busy_cpus, sg->group_weight);
 }
 
 int __weak arch_sd_sibling_asym_packing(void)
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 50c06b0e9fab..e050563e97a4 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -4901,6 +4901,36 @@ static void nohz_balancer_kick(int cpu)
         return;
 }
 
+static inline void set_cpu_sd_state_busy(void)
+{
+        struct sched_domain *sd;
+        int cpu = smp_processor_id();
+
+        if (!test_bit(NOHZ_IDLE, nohz_flags(cpu)))
+                return;
+        clear_bit(NOHZ_IDLE, nohz_flags(cpu));
+
+        rcu_read_lock();
+        for_each_domain(cpu, sd)
+                atomic_inc(&sd->groups->sgp->nr_busy_cpus);
+        rcu_read_unlock();
+}
+
+void set_cpu_sd_state_idle(void)
+{
+        struct sched_domain *sd;
+        int cpu = smp_processor_id();
+
+        if (test_bit(NOHZ_IDLE, nohz_flags(cpu)))
+                return;
+        set_bit(NOHZ_IDLE, nohz_flags(cpu));
+
+        rcu_read_lock();
+        for_each_domain(cpu, sd)
+                atomic_dec(&sd->groups->sgp->nr_busy_cpus);
+        rcu_read_unlock();
+}
+
 /*
  * This routine will try to nominate the ilb (idle load balancing)
  * owner among the cpus whose ticks are stopped. ilb owner will do the idle
@@ -5135,6 +5165,7 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)
         * We may be recently in ticked or tickless idle mode. At the first
         * busy tick after returning from idle, we will update the busy stats.
         */
+        set_cpu_sd_state_busy();
         if (unlikely(test_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu))))
                 clear_bit(NOHZ_TICK_STOPPED, nohz_flags(cpu));
 
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index cf7d02662bc2..91810f0ee3af 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -1069,6 +1069,7 @@ extern void account_cfs_bandwidth_used(int enabled, int was_enabled);
 enum rq_nohz_flag_bits {
         NOHZ_TICK_STOPPED,
         NOHZ_BALANCE_KICK,
+        NOHZ_IDLE,
 };
 
 #define nohz_flags(cpu) (&cpu_rq(cpu)->nohz_flags)
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 40420644d0ba..31cc06163ed5 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -297,6 +297,15 @@ void tick_nohz_stop_sched_tick(int inidle)
         ts = &per_cpu(tick_cpu_sched, cpu);
 
         /*
+         * Update the idle state in the scheduler domain hierarchy
+         * when tick_nohz_stop_sched_tick() is called from the idle loop.
+         * State will be updated to busy during the first busy tick after
+         * exiting idle.
+         */
+        if (inidle)
+                set_cpu_sd_state_idle();
+
+        /*
          * Call to tick_nohz_start_idle stops the last_update_time from being
          * updated. Thus, it must not be called in the event we are called from
          * irq_exit() with the prior state different than idle.