1 files changed, 32 insertions, 40 deletions

diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index 2efe629425be..962cf343f798 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -13,6 +13,8 @@
 #include <linux/sched/cpufreq.h>
 #include <trace/events/power.h>
 
+#define IOWAIT_BOOST_MIN        (SCHED_CAPACITY_SCALE / 8)
+
 struct sugov_tunables {
         struct gov_attr_set     attr_set;
         unsigned int            rate_limit_us;
@@ -48,7 +50,6 @@ struct sugov_cpu {
 
         bool                    iowait_boost_pending;
         unsigned int            iowait_boost;
-        unsigned int            iowait_boost_max;
         u64                     last_update;
 
         unsigned long           bw_dl;
@@ -291,8 +292,8 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
  *
  * The IO wait boost of a task is disabled after a tick since the last update
  * of a CPU. If a new IO wait boost is requested after more then a tick, then
- * we enable the boost starting from the minimum frequency, which improves
- * energy efficiency by ignoring sporadic wakeups from IO.
+ * we enable the boost starting from IOWAIT_BOOST_MIN, which improves energy
+ * efficiency by ignoring sporadic wakeups from IO.
  */
 static bool sugov_iowait_reset(struct sugov_cpu *sg_cpu, u64 time,
                                bool set_iowait_boost)
@@ -303,8 +304,7 @@ static bool sugov_iowait_reset(struct sugov_cpu *sg_cpu, u64 time,
         if (delta_ns <= TICK_NSEC)
                 return false;
 
-        sg_cpu->iowait_boost = set_iowait_boost
-                ? sg_cpu->sg_policy->policy->min : 0;
+        sg_cpu->iowait_boost = set_iowait_boost ? IOWAIT_BOOST_MIN : 0;
         sg_cpu->iowait_boost_pending = set_iowait_boost;
 
         return true;
@@ -318,8 +318,9 @@ static bool sugov_iowait_reset(struct sugov_cpu *sg_cpu, u64 time,
  *
  * Each time a task wakes up after an IO operation, the CPU utilization can be
  * boosted to a certain utilization which doubles at each "frequent and
- * successive" wakeup from IO, ranging from the utilization of the minimum
- * OPP to the utilization of the maximum OPP.
+ * successive" wakeup from IO, ranging from IOWAIT_BOOST_MIN to the utilization
+ * of the maximum OPP.
+ *
  * To keep doubling, an IO boost has to be requested at least once per tick,
  * otherwise we restart from the utilization of the minimum OPP.
  */
@@ -344,14 +345,13 @@ static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, u64 time,
 
         /* Double the boost at each request */
         if (sg_cpu->iowait_boost) {
-                sg_cpu->iowait_boost <<= 1;
-                if (sg_cpu->iowait_boost > sg_cpu->iowait_boost_max)
-                        sg_cpu->iowait_boost = sg_cpu->iowait_boost_max;
+                sg_cpu->iowait_boost =
+                        min_t(unsigned int, sg_cpu->iowait_boost << 1, SCHED_CAPACITY_SCALE);
                 return;
         }
 
         /* First wakeup after IO: start with minimum boost */
-        sg_cpu->iowait_boost = sg_cpu->sg_policy->policy->min;
+        sg_cpu->iowait_boost = IOWAIT_BOOST_MIN;
 }
 
 /**
@@ -373,47 +373,38 @@ static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, u64 time,
  * This mechanism is designed to boost high frequently IO waiting tasks, while
  * being more conservative on tasks which does sporadic IO operations.
  */
-static void sugov_iowait_apply(struct sugov_cpu *sg_cpu, u64 time,
-                               unsigned long *util, unsigned long *max)
+static unsigned long sugov_iowait_apply(struct sugov_cpu *sg_cpu, u64 time,
+                                        unsigned long util, unsigned long max)
 {
-        unsigned int boost_util, boost_max;
+        unsigned long boost;
 
         /* No boost currently required */
         if (!sg_cpu->iowait_boost)
-                return;
+                return util;
 
         /* Reset boost if the CPU appears to have been idle enough */
         if (sugov_iowait_reset(sg_cpu, time, false))
-                return;
+                return util;
 
-        /*
-         * An IO waiting task has just woken up:
-         * allow to further double the boost value
-         */
-        if (sg_cpu->iowait_boost_pending) {
-                sg_cpu->iowait_boost_pending = false;
-        } else {
+        if (!sg_cpu->iowait_boost_pending) {
                 /*
-                 * Otherwise: reduce the boost value and disable it when we
-                 * reach the minimum.
+                 * No boost pending; reduce the boost value.
                  */
                 sg_cpu->iowait_boost >>= 1;
-                if (sg_cpu->iowait_boost < sg_cpu->sg_policy->policy->min) {
+                if (sg_cpu->iowait_boost < IOWAIT_BOOST_MIN) {
                         sg_cpu->iowait_boost = 0;
-                        return;
+                        return util;
                 }
         }
 
+        sg_cpu->iowait_boost_pending = false;
+
         /*
-         * Apply the current boost value: a CPU is boosted only if its current
-         * utilization is smaller then the current IO boost level.
+         * @util is already in capacity scale; convert iowait_boost
+         * into the same scale so we can compare.
          */
-        boost_util = sg_cpu->iowait_boost;
-        boost_max = sg_cpu->iowait_boost_max;
-        if (*util * boost_max < *max * boost_util) {
-                *util = boost_util;
-                *max = boost_max;
-        }
+        boost = (sg_cpu->iowait_boost * max) >> SCHED_CAPACITY_SHIFT;
+        return max(boost, util);
 }
 
 #ifdef CONFIG_NO_HZ_COMMON
@@ -460,7 +451,7 @@ static void sugov_update_single(struct update_util_data *hook, u64 time,
 
         util = sugov_get_util(sg_cpu);
         max = sg_cpu->max;
-        sugov_iowait_apply(sg_cpu, time, &util, &max);
+        util = sugov_iowait_apply(sg_cpu, time, util, max);
         next_f = get_next_freq(sg_policy, util, max);
         /*
          * Do not reduce the frequency if the CPU has not been idle
@@ -500,7 +491,7 @@ static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu, u64 time)
 
                 j_util = sugov_get_util(j_sg_cpu);
                 j_max = j_sg_cpu->max;
-                sugov_iowait_apply(j_sg_cpu, time, &j_util, &j_max);
+                j_util = sugov_iowait_apply(j_sg_cpu, time, j_util, j_max);
 
                 if (j_util * max > j_max * util) {
                         util = j_util;
@@ -609,13 +600,14 @@ rate_limit_us_store(struct gov_attr_set *attr_set, const char *buf, size_t count
 
 static struct governor_attr rate_limit_us = __ATTR_RW(rate_limit_us);
 
-static struct attribute *sugov_attributes[] = {
+static struct attribute *sugov_attrs[] = {
         &rate_limit_us.attr,
         NULL
 };
+ATTRIBUTE_GROUPS(sugov);
 
 static struct kobj_type sugov_tunables_ktype = {
-        .default_attrs = sugov_attributes,
+        .default_groups = sugov_groups,
         .sysfs_ops = &governor_sysfs_ops,
 };
 
@@ -782,6 +774,7 @@ out:
         return 0;
 
 fail:
+        kobject_put(&tunables->attr_set.kobj);
         policy->governor_data = NULL;
         sugov_tunables_free(tunables);
 
@@ -837,7 +830,6 @@ static int sugov_start(struct cpufreq_policy *policy)
                 memset(sg_cpu, 0, sizeof(*sg_cpu));
                 sg_cpu->cpu                     = cpu;
                 sg_cpu->sg_policy               = sg_policy;
-                sg_cpu->iowait_boost_max        = policy->cpuinfo.max_freq;
         }
 
         for_each_cpu(cpu, policy->cpus) {