Two small fixes for bandwidth controller
cover Two small fixes for bandwidth controller
This series contains two small fixes for bandwidth controller, and also preparation for burstable CFS bandwidth controller.
Huaixin Chang (2):
sched: Defend cfs and rt bandwidth quota against overflow sched/fair: Refill bandwidth before scaling
kernel/sched/core.c | 8 ++++++++ kernel/sched/fair.c | 4 ++-- kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 4 files changed, 21 insertions(+), 2 deletions(-)
Signature · 1 line
2.14.4.44.g2045bb6
PATCH 1/2 sched: Defend cfs and rt bandwidth quota against overflow
Kernel limitation on cpu.cfs_quota_us is insufficient. Some large numbers might cause overflow in to_ratio() calculation and produce unexpected results.
For example, if we make two cpu cgroups and then write a reasonable value and a large value into child's and parent's cpu.cfs_quota_us. This will cause a write error.
cd /sys/fs/cgroup/cpu mkdir parent; mkdir parent/child echo 8000 > parent/child/cpu.cfs_quota_us # 17592186044416 is (1UL << 44) echo 17592186044416 > parent/cpu.cfs_quota_us
In this case, quota will overflow and thus fail the __cfs_schedulable check. Similar overflow also affects rt bandwidth.
--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)
kernel/sched/core.c +8 -0
@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW_USEC *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);
@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs().
kernel/sched/rt.c +9 -0
@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; } +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW_USEC *NSEC_PER_USEC ; +static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {
@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)
kernel/sched/sched.h +2 -0
@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
Signature · 1 line
2.14.4.44.g2045bb6
[email protected]
reviewerRe: [PATCH 1/2] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 8 lines · Huaixin Chang
Kernel limitation on cpu.cfs_quota_us is insufficient. Some large numbers might cause overflow in
to_ratio()calculation and produce unexpected results.For example, if we make two cpu cgroups and then write a reasonable value and a large value into child's and parent's cpu.cfs_quota_us. This will cause a write error.
Quoted 8 lines
cd /sys/fs/cgroup/cpu mkdir parent; mkdir parent/child echo 8000 > parent/child/cpu.cfs_quota_us # 17592186044416 is (1UL << 44) echo 17592186044416 > parent/cpu.cfs_quota_usIn this case, quota will overflow and thus fail the
__cfs_schedulablecheck. Similar overflow also affects rt bandwidth.
More to the point is that I think doing
echo 17592186044416 > parent/cpu.cfs_quota_us
echo 8000 > parent/child/cpu.cfs_quota_us
will only fail on the second write, while with this patch it will fail on the first, which should be more understandable.
to_ratio could be altered to avoid unnecessary internal overflow, but min_cfs_quota_period is less than 1<<BW_SHIFT, so a cutoff would still be needed.
Also tg_rt_schedulable sums a bunch of to_ratio(), and doesn't check for overflow on that sum, so if we consider preventing weirdness around schedulable checks and max quotas relevant we should probably fix that too.
Quoted 39 lines
Signed-off-by Huaixin Chang <[email protected]>--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)kernel/sched/core.c +8
-0@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW_USEC *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). kernel/sched/rt.c +0
-0
kernel/sched/rt.c static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime) · line 2573
Quoted 5 lines
kernel/sched/rt.c +2
-0@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; } +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW_USEC *NSEC_PER_USEC ;
It looks to me like __rt_schedulable doesn't divide by NSEC_PER_USEC, so to_ratio is operating on nsec, and the limit is in nsec, and MAX_BW_USEC should probably not be named USEC then as well.
Quoted 30 lines
kernel/sched/rt.c +7
-0+static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)kernel/sched/sched.h +2
-0@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
Re: [PATCH 1/2] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 28 lines · 在 2020年4月21日,上午1:50,[email protected] 写道:
Quoted 8 lines · Huaixin Chang
Kernel limitation on cpu.cfs_quota_us is insufficient. Some large numbers might cause overflow in
to_ratio()calculation and produce unexpected results.For example, if we make two cpu cgroups and then write a reasonable value and a large value into child's and parent's cpu.cfs_quota_us. This will cause a write error.
Quoted 8 lines
cd /sys/fs/cgroup/cpu mkdir parent; mkdir parent/child echo 8000 > parent/child/cpu.cfs_quota_us # 17592186044416 is (1UL << 44) echo 17592186044416 > parent/cpu.cfs_quota_usIn this case, quota will overflow and thus fail the
__cfs_schedulablecheck. Similar overflow also affects rt bandwidth.More to the point is that I think doing
echo 17592186044416 > parent/cpu.cfs_quota_us
echo 8000 > parent/child/cpu.cfs_quota_us
Quoted 8 lines
will only fail on the second write, while with this patch it will fail on the first, which should be more understandable.
to_ratiocould be altered to avoid unnecessary internal overflow, butmin_cfs_quota_periodis less than 1<<BW_SHIFT, so a cutoff would still be needed.
Yes, I will rewrite commit log in the following patch.
Quoted 4 lines
Also
tg_rt_schedulablesums a bunch ofto_ratio(), and doesn't check for overflow on that sum, so if we consider preventing weirdness around schedulable checks and max quotas relevant we should probably fix that too.
It seems to me that check for overflow on sum of to_ratio(rt_period, rt_runtime) is not necessary. As to_ratio() of a rt group is bounded by global_rt_period() and global_rt_runtime() due to the checks in tg_rt_schedulable(). And global_rt_runtime() is not allowed to be greater than global_rt_period() thanks to sched_rt_global_validate(). Thus, to_ratio() of a rt group will not exceed BW_UNIT, sum of which is unlikely to overflow then. Checks against rt_runtime overflow during to_ratio is still needed.
Is that correct?
Quoted 42 lines
Quoted 42 lines
Signed-off-by Huaixin Chang <[email protected]>---
kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)kernel/sched/core.c +0
-0@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64
max_cfs_quota_period= 1 *NSEC_PER_SEC; /* 1s */ static const u64min_cfs_quota_period= 1 *NSEC_PER_MSEC; /* 1ms */kernel/sched/core.c +2
-0+/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW_USEC *NSEC_PER_USEC ;static int
__cfs_schedulable(struct task_group *tg, u64 period, u64 runtime);kernel/sched/core.c +6
-0@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). kernel/sched/rt.c +0
-0@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; }
Quoted 6 lines
kernel/sched/rt.c static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime) · line 2573
Quoted 2 lines
kernel/sched/rt.c +2
-0+/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW_USEC *NSEC_PER_USEC ;It looks to me like
__rt_schedulabledoesn't divide byNSEC_PER_USEC, soto_ratiois operating on nsec, and the limit is in nsec, andMAX_BW_USECshould probably not be named USEC then as well.
Yes, the limit for rt_runtime is in nsec. This should be changed.
Quoted 31 lines
Quoted 31 lines
kernel/sched/rt.c +7
-0+static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)kernel/sched/sched.h +2
-0@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
[email protected]
reviewerRe: [PATCH 1/2] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 50 lines · changhuaixin
Quoted 26 lines · 在 2020年4月21日,上午1:50,[email protected] 写道:
Quoted 8 lines · Huaixin Chang
Kernel limitation on cpu.cfs_quota_us is insufficient. Some large numbers might cause overflow in
to_ratio()calculation and produce unexpected results.For example, if we make two cpu cgroups and then write a reasonable value and a large value into child's and parent's cpu.cfs_quota_us. This will cause a write error.
Quoted 8 lines
cd /sys/fs/cgroup/cpu mkdir parent; mkdir parent/child echo 8000 > parent/child/cpu.cfs_quota_us # 17592186044416 is (1UL << 44) echo 17592186044416 > parent/cpu.cfs_quota_usIn this case, quota will overflow and thus fail the
__cfs_schedulablecheck. Similar overflow also affects rt bandwidth.More to the point is that I think doing
echo 17592186044416 > parent/cpu.cfs_quota_us
echo 8000 > parent/child/cpu.cfs_quota_usQuoted 8 lines
will only fail on the second write, while with this patch it will fail on the first, which should be more understandable.
to_ratiocould be altered to avoid unnecessary internal overflow, butmin_cfs_quota_periodis less than 1<<BW_SHIFT, so a cutoff would still be needed.Yes, I will rewrite commit log in the following patch.
Quoted 4 lines
Also
tg_rt_schedulablesums a bunch ofto_ratio(), and doesn't check for overflow on that sum, so if we consider preventing weirdness around schedulable checks and max quotas relevant we should probably fix that too.It seems to me that check for overflow on sum of
to_ratio(rt_period, rt_runtime)is not necessary. Asto_ratio()of a rt group is bounded byglobal_rt_period()andglobal_rt_runtime()due to the checks intg_rt_schedulable(). Andglobal_rt_runtime()is not allowed to be greater thanglobal_rt_period()thanks tosched_rt_global_validate(). Thus,to_ratio()of a rt group will not exceedBW_UNIT, sum of which is unlikely to overflow then. Checks againstrt_runtimeoverflow duringto_ratiois still needed.
Quoted 1 line
Is that correct?
Good point, that's probably not a problem then.
Quoted 83 lines
Quoted 43 lines
Quoted 43 lines
Signed-off-by Huaixin Chang <[email protected]>---
kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)kernel/sched/core.c +0
-0@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64
max_cfs_quota_period= 1 *NSEC_PER_SEC; /* 1s */ static const u64min_cfs_quota_period= 1 *NSEC_PER_MSEC; /* 1ms */kernel/sched/core.c +2
-0+/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW_USEC *NSEC_PER_USEC ;static int
__cfs_schedulable(struct task_group *tg, u64 period, u64 runtime);kernel/sched/core.c +6
-0@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). kernel/sched/rt.c +0
-0@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; }Quoted 6 lines
kernel/sched/rt.c static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime) · line 2573
Quoted 2 lines
kernel/sched/rt.c +2
-0+/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW_USEC *NSEC_PER_USEC ;It looks to me like
__rt_schedulabledoesn't divide byNSEC_PER_USEC, soto_ratiois operating on nsec, and the limit is in nsec, andMAX_BW_USECshould probably not be named USEC then as well.Yes, the limit for
rt_runtimeis in nsec. This should be changed.Quoted 31 lines
Quoted 31 lines
kernel/sched/rt.c +7
-0+static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)kernel/sched/sched.h +2
-0@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
PATCH 1/1 sched: Defend cfs and rt bandwidth quota against overflow
In reply to [email protected]When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during to_ratio() shifts of schedulable checks.
to_ratio() could be altered to avoid unnecessary internal overflow, but min_cfs_quota_period is less than 1 << BW_SHIFT, so a cutoff would still be needed. Set a cap MAX_BW for cfs_quota_us and rt_runtime_us to prevent overflow.
--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)
kernel/sched/core.c +8 -0
@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);
@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs().
kernel/sched/rt.c +9 -0
@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; } +/* More than 4 hours if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW ; +static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {
@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)
kernel/sched/sched.h +2 -0
@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW ((1ULL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
Signature · 1 line
2.14.4.44.g2045bb6
[email protected]
reviewerRe: [PATCH] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 57 lines · Huaixin Chang
When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during
to_ratio()shifts of schedulable checks.
to_ratio()could be altered to avoid unnecessary internal overflow, butmin_cfs_quota_periodis less than 1 <<BW_SHIFT, so a cutoff would still be needed. Set a capMAX_BWforcfs_quota_usandrt_runtime_usto prevent overflow.Signed-off-by Huaixin Chang <[email protected]>--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 9 +++++++++ kernel/sched/sched.h | 2 ++ 3 files changed, 19 insertions(+)kernel/sched/core.c +8
-0@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). kernel/sched/rt.c +3
-0@@ -2569,6 +2569,9 @@ static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)return ret; } +/* More than 4 hours if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW ; +static int tg_set_rt_bandwidth (struct task_group *tg,u64 rt_period,u64 rt_runtime) {
kernel/sched/rt.c static int tg_set_rt_bandwidth(struct task_group *tg, · line 2596
Quoted 9 lines
kernel/sched/rt.c +6
-0@@ -2585,6 +2588,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +
We probably _do_ also want this in sched_rt_global_validate now that I think of it. Other than missing that, it looks good.
Quoted 16 lines
kernel/sched/rt.c +0
-0mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)kernel/sched/sched.h +2
-0@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW ((1ULL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
PATCH v2 1/1 sched: Defend cfs and rt bandwidth quota against overflow
When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during to_ratio() shifts of schedulable checks.
to_ratio() could be altered to avoid unnecessary internal overflow, but min_cfs_quota_period is less than 1 << BW_SHIFT, so a cutoff would still be needed. Set a cap MAX_BW for cfs_quota_us and rt_runtime_us to prevent overflow.
--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 12 +++++++++++- kernel/sched/sched.h | 2 ++ 3 files changed, 21 insertions(+), 1 deletion(-)
kernel/sched/core.c +8 -0
@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);
@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs().
kernel/sched/rt.c +11 -1
@@ -9,6 +9,8 @@int sched_rr_timeslice =RR_TIMESLICE ;int sysctl_sched_rr_timeslice = (MSEC_PER_SEC /HZ ) *RR_TIMESLICE ; +/* More than 4 hours if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW ;static int do_sched_rt_period_timer (struct rt_bandwidth *rt_b,int overrun);
@@ -2585,6 +2587,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)
@@ -2702,7 +2710,9 @@ static int sched_rt_global_validate(void)return -EINVAL ;if ((sysctl_sched_rt_runtime !=RUNTIME_INF ) && - (sysctl_sched_rt_runtime > sysctl_sched_rt_period)) + ((sysctl_sched_rt_runtime > sysctl_sched_rt_period) || + ((u64 )sysctl_sched_rt_runtime * +NSEC_PER_USEC > max_rt_runtime)))return -EINVAL ;return 0 ;
kernel/sched/sched.h +2 -0
@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW ((1ULL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
Signature · 1 line
2.14.4.44.g2045bb6
Re: [PATCH v2] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 8 lines · Huaixin Chang
When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during
to_ratio()shifts of schedulable checks.
to_ratio()could be altered to avoid unnecessary internal overflow, butmin_cfs_quota_periodis less than 1 <<BW_SHIFT, so a cutoff would still be needed. Set a capMAX_BWforcfs_quota_usandrt_runtime_usto prevent overflow.
Quoted 84 lines
Signed-off-by Huaixin Chang <[email protected]>--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 12 +++++++++++- kernel/sched/sched.h | 2 ++ 3 files changed, 21 insertions(+), 1 deletion(-)kernel/sched/core.c +8
-0@@ -7390,6 +7390,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);@@ -7417,6 +7419,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)if (period > max_cfs_quota_period)return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). kernel/sched/rt.c +11
-1@@ -9,6 +9,8 @@int sched_rr_timeslice =RR_TIMESLICE ;int sysctl_sched_rr_timeslice = (MSEC_PER_SEC /HZ ) *RR_TIMESLICE ; +/* More than 4 hours if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW ;static int do_sched_rt_period_timer (struct rt_bandwidth *rt_b,int overrun);@@ -2585,6 +2587,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)@@ -2702,7 +2710,9 @@ static int sched_rt_global_validate(void)return -EINVAL ;if ((sysctl_sched_rt_runtime !=RUNTIME_INF ) && - (sysctl_sched_rt_runtime > sysctl_sched_rt_period)) + ((sysctl_sched_rt_runtime > sysctl_sched_rt_period) || + ((u64 )sysctl_sched_rt_runtime * +NSEC_PER_USEC > max_rt_runtime)))return -EINVAL ;return 0 ;kernel/sched/sched.h +2
-0@@ -1918,6 +1918,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW ((1ULL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
Peter Zijlstra
maintainerRe: [PATCH v2] sched: Defend cfs and rt bandwidth quota against overflow
Quoted 6 lines · On Mon, Apr 27, 2020 at 11:29:30AM -0700, [email protected] wrote:
Quoted 4 lines · Huaixin Chang
When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during
to_ratio()shifts of schedulable checks.
Quoted 6 lines
Quoted 4 lines
to_ratio()could be altered to avoid unnecessary internal overflow, butmin_cfs_quota_periodis less than 1 <<BW_SHIFT, so a cutoff would still be needed. Set a capMAX_BWforcfs_quota_usandrt_runtime_usto prevent overflow.Reviewed-by Ben Segall <[email protected]>
Thanks!
[tip: sched/core] sched: Defend cfs and rt bandwidth quota against overflow
In reply to Huaixin ChangThe following commit has been merged into the sched/core branch of tip:
The following commit has been merged into the sched/core branch of tip:
Commit-ID: d505b8af58912ae1e1a211fabc9995b19bd40828 Gitweb: https://git.kernel.org/tip/d505b8af58912ae1e1a211fabc9995b19bd40828 Author: Huaixin Chang <[email protected]> AuthorDate: Sat, 25 Apr 2020 18:52:48 +08:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Tue, 19 May 2020 20:34:14 +02:00
sched: Defend cfs and rt bandwidth quota against overflow
When users write some huge number into cpu.cfs_quota_us or cpu.rt_runtime_us, overflow might happen during to_ratio() shifts of schedulable checks.
to_ratio() could be altered to avoid unnecessary internal overflow, but min_cfs_quota_period is less than 1 << BW_SHIFT, so a cutoff would still be needed. Set a cap MAX_BW for cfs_quota_us and rt_runtime_us to prevent overflow.
--- kernel/sched/core.c | 8 ++++++++ kernel/sched/rt.c | 12 +++++++++++- kernel/sched/sched.h | 2 ++ 3 files changed, 21 insertions(+), 1 deletion(-)
kernel/sched/core.c +8 -0
@@ -7379,6 +7379,8 @@ static DEFINE_MUTEX(cfs_constraints_mutex);const u64 max_cfs_quota_period =1 *NSEC_PER_SEC ;/* 1s */ static const u64 min_cfs_quota_period =1 *NSEC_PER_MSEC ;/* 1ms */ +/* More than 203 days if BW_SHIFT equals 20. */ +static const u64 max_cfs_runtime =MAX_BW *NSEC_PER_USEC ;static int __cfs_schedulable (struct task_group *tg,u64 period,u64 runtime);
@@ -7407,6 +7409,12 @@ static int tg_set_cfs_bandwidth(struct task_group *tg, u64 period, u64 quota)return -EINVAL ;/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (quota !=RUNTIME_INF && quota > max_cfs_runtime) +return -EINVAL ; + +/* * Prevent race between setting of cfs_rq->runtime_enabled and * unthrottle_offline_cfs_rqs(). */
kernel/sched/rt.c +11 -1
@@ -9,6 +9,8 @@int sched_rr_timeslice =RR_TIMESLICE ;int sysctl_sched_rr_timeslice = (MSEC_PER_SEC /HZ ) *RR_TIMESLICE ; +/* More than 4 hours if BW_SHIFT equals 20. */ +static const u64 max_rt_runtime =MAX_BW ;static int do_sched_rt_period_timer (struct rt_bandwidth *rt_b,int overrun);
@@ -2585,6 +2587,12 @@ static int tg_set_rt_bandwidth(struct task_group *tg,if (rt_period ==0 )return -EINVAL ; +/* +* Bound quota to defend quota against overflow during bandwidth shift. +*/ +if (rt_runtime !=RUNTIME_INF && rt_runtime > max_rt_runtime) +return -EINVAL ; +mutex_lock (&rt_constraints_mutex); err =__rt_schedulable (tg, rt_period, rt_runtime);if (err)
@@ -2702,7 +2710,9 @@ static int sched_rt_global_validate(void)return -EINVAL ;if ((sysctl_sched_rt_runtime !=RUNTIME_INF ) && - (sysctl_sched_rt_runtime > sysctl_sched_rt_period)) + ((sysctl_sched_rt_runtime > sysctl_sched_rt_period) || + ((u64 )sysctl_sched_rt_runtime * +NSEC_PER_USEC > max_rt_runtime)))return -EINVAL ;return 0 ;
kernel/sched/sched.h +2 -0
@@ -1915,6 +1915,8 @@ extern void init_dl_inactive_task_timer(struct sched_dl_entity *dl_se);#define BW_SHIFT 20#define BW_UNIT (1 << BW_SHIFT)#define RATIO_SHIFT 8 +#define MAX_BW_BITS (64 - BW_SHIFT) +#define MAX_BW ((1ULL << MAX_BW_BITS) - 1)unsigned long to_ratio (u64 period,u64 runtime);extern void init_entity_runnable_average (struct sched_entity *se);
kbuild test robot
build botRe: [PATCH 1/2] sched: Defend cfs and rt bandwidth quota against overflow
In reply to Huaixin ChangThank you for the patch! Perhaps something to improve:
Hi Huaixin,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on tip/sched/core]
[also build test WARNING on tip/auto-latest linus/master linux/master v5.7-rc2 next-20200421] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Huaixin-Chang/Two-small-fixes-for-bandwidth-controller/20200421-230027 base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git 8f3d9f354286745c751374f5f1fcafee6b3f3136 config: sh-allmodconfig (attached as .config) compiler: sh4-linux-gcc (GCC) 9.3.0
reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day GCC_VERSION=9.3.0 make.cross ARCH=sh
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
In file included from kernel/sched/core.c:9:
>> kernel/sched/sched.h:1922:28: warning: left shift count >= width of type [-Wshift-count-overflow]
1922 | #define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)
| ^~
>> kernel/sched/core.c:7394:36: note: in expansion of macro 'MAX_BW_USEC'
7394 | static const u64 max_cfs_runtime = MAX_BW_USEC * NSEC_PER_USEC;
| ^~~~~~~~~~~
--
In file included from kernel/sched/rt.c:6:
>> kernel/sched/sched.h:1922:28: warning: left shift count >= width of type [-Wshift-count-overflow]
1922 | #define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)
| ^~
>> kernel/sched/rt.c:2573:35: note: in expansion of macro 'MAX_BW_USEC'
2573 | static const u64 max_rt_runtime = MAX_BW_USEC * NSEC_PER_USEC;
| ^~~~~~~~~~~vim +1922 kernel/sched/sched.h
1917
1918 #define BW_SHIFT 20
1919 #define BW_UNIT (1 << BW_SHIFT)
1920 #define RATIO_SHIFT 8
1921 #define MAX_BW_BITS (64 - BW_SHIFT)
> 1922 #define MAX_BW_USEC ((1UL << MAX_BW_BITS) - 1)
1923 unsigned long to_ratio(u64 period, u64 runtime);
1924
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/[email protected]
kbuild test robot
build botRe: [PATCH 1/2] sched: Defend cfs and rt bandwidth quota against overflow
In reply to Huaixin ChangThank you for the patch! Yet something to improve:
Hi Huaixin,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on tip/sched/core]
[also build test ERROR on tip/auto-latest linus/master v5.7-rc2 next-20200423] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/Huaixin-Chang/Two-small-fixes-for-bandwidth-controller/20200421-230027 base: https://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git 8f3d9f354286745c751374f5f1fcafee6b3f3136 config: i386-randconfig-a001-20200424 (attached as .config) compiler: gcc-4.9 (Ubuntu 4.9.3-13ubuntu2) 4.9.3 reproduce: # save the attached .config to linux build tree make ARCH=i386
If you fix the issue, kindly add following tag as appropriate
All error/warnings (new ones prefixed by >>):
>> kernel/sched/core.c:7394:1: warning: left shift count >= width of type
static const u64 max_cfs_runtime = MAX_BW_USEC * NSEC_PER_USEC;
^
>> kernel/sched/core.c:7394:1: error: initializer element is not computable at load timevim +7394 kernel/sched/core.c
7390
7391 const u64 max_cfs_quota_period = 1 * NSEC_PER_SEC; /* 1s */
7392 static const u64 min_cfs_quota_period = 1 * NSEC_PER_MSEC; /* 1ms */
7393 /* More than 203 days if BW_SHIFT equals 20. */
> 7394 static const u64 max_cfs_runtime = MAX_BW_USEC * NSEC_PER_USEC;
7395
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
PATCH 2/2 sched/fair: Refill bandwidth before scaling
In reply to Huaixin ChangIn order to prevent possible hardlockup of sched_cfs_period_timer() loop, loop count is introduced to denote whether to scale quota and period or not. However, scale is done between forwarding period timer and refilling cfs bandwidth runtime, which means that period timer is forwarded with old "period" while runtime is refilled with scaled "quota".
Move do_sched_cfs_period_timer() before scaling to solve this.
--- kernel/sched/fair.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/sched/fair.c +2 -2
@@ -5152,6 +5152,8 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)if (!overrun)break ; + idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); +if (++count >3 ) {u64 new, old =ktime_to_ns (cfs_b->period);
@@ -5181,8 +5183,6 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)/* reset count so we don't come right back in here */ count =0 ; } - - idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); }if (idle) cfs_b->period_active =0 ;
Signature · 1 line
2.14.4.44.g2045bb6
Re: [PATCH 2/2] sched/fair: Refill bandwidth before scaling
Quoted 8 lines · Huaixin Chang
In order to prevent possible hardlockup of
sched_cfs_period_timer()loop, loop count is introduced to denote whether to scale quota and period or not. However, scale is done between forwarding period timer and refilling cfs bandwidth runtime, which means that period timer is forwarded with old "period" while runtime is refilled with scaled "quota".Move
do_sched_cfs_period_timer()before scaling to solve this.
Quoted 29 lines
Fixes 2e8e19226398 ("sched/fair: Limit sched_cfs_period_timer() loop to avoid hard lockup")Signed-off-by Huaixin Chang <[email protected]>--- kernel/sched/fair.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)kernel/sched/fair.c +2
-2@@ -5152,6 +5152,8 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)if (!overrun)break ; + idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); +if (++count >3 ) {u64 new, old =ktime_to_ns (cfs_b->period);@@ -5181,8 +5183,6 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)/* reset count so we don't come right back in here */ count =0 ; } - - idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); }if (idle) cfs_b->period_active =0 ;
Re: [PATCH 2/2] sched/fair: Refill bandwidth before scaling
In reply to Huaixin ChangHi,
Quoted 40 lines · On Mon, Apr 20, 2020 at 10:44:21AM +0800 Huaixin Chang wrote:
In order to prevent possible hardlockup of
sched_cfs_period_timer()loop, loop count is introduced to denote whether to scale quota and period or not. However, scale is done between forwarding period timer and refilling cfs bandwidth runtime, which means that period timer is forwarded with old "period" while runtime is refilled with scaled "quota".Move
do_sched_cfs_period_timer()before scaling to solve this.Fixes 2e8e19226398 ("sched/fair: Limit sched_cfs_period_timer() loop to avoid hard lockup")Signed-off-by Huaixin Chang <[email protected]>--- kernel/sched/fair.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)kernel/sched/fair.c +2
-2@@ -5152,6 +5152,8 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)if (!overrun)break ; + idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); +if (++count >3 ) {u64 new, old =ktime_to_ns (cfs_b->period);@@ -5181,8 +5183,6 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)/* reset count so we don't come right back in here */ count =0 ; } - - idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); }if (idle) cfs_b->period_active =0 ;Signature · 1 line
2.14.4.44.g2045bb6
This one is independent of the first so could be taken as is.
[tip: sched/core] sched/fair: Refill bandwidth before scaling
In reply to Huaixin ChangThe following commit has been merged into the sched/core branch of tip:
The following commit has been merged into the sched/core branch of tip:
Commit-ID: 5a6d6a6ccb5f48ca8cf7c6d64ff83fd9c7999390 Gitweb: https://git.kernel.org/tip/5a6d6a6ccb5f48ca8cf7c6d64ff83fd9c7999390 Author: Huaixin Chang <[email protected]> AuthorDate: Mon, 20 Apr 2020 10:44:21 +08:00 Committer: Peter Zijlstra <[email protected]> CommitterDate: Thu, 30 Apr 2020 20:14:40 +02:00
sched/fair: Refill bandwidth before scaling
In order to prevent possible hardlockup of sched_cfs_period_timer() loop, loop count is introduced to denote whether to scale quota and period or not. However, scale is done between forwarding period timer and refilling cfs bandwidth runtime, which means that period timer is forwarded with old "period" while runtime is refilled with scaled "quota".
Move do_sched_cfs_period_timer() before scaling to solve this.
--- kernel/sched/fair.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/sched/fair.c +2 -2
@@ -5159,6 +5159,8 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)if (!overrun)break ; + idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); +if (++count >3 ) {u64 new, old =ktime_to_ns (cfs_b->period);
@@ -5188,8 +5190,6 @@ static enum hrtimer_restart sched_cfs_period_timer(struct hrtimer *timer)/* reset count so we don't come right back in here */ count =0 ; } - - idle =do_sched_cfs_period_timer (cfs_b, overrun, flags); }if (idle) cfs_b->period_active =0 ;