sched/dl: Implement cancel_dl_timer() to use in switched_from_dl()
PATCH v2 1/3 sched/dl: Implement cancel_dl_timer() to use in switched_from_dl()
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel() may bring a suprise, its call may fail.
raw_spin_lock(&rq->lock)
... dl_task_timer raw_spin_lock(&rq->lock)
... raw_spin_lock(&rq->lock) ...
switched_from_dl() ... ...
hrtimer_try_to_cancel() ... ...
switched_to_fair() ... ...
... ... ...
... ... ...
raw_spin_unlock(&rq->lock) ... (asquired)
... ... ...
... ... ...
do_exit() ... ...
schedule() ... ...
raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock)
... ... ...
raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock)
... ... (asquired)
put_task_struct() ... ...
free_task_struct() ... ...
... ... raw_spin_unlock(&rq->lock)
... (asquired) ...
... ... ...
... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
We do not create any problem with rq unlocking, because it already may happed below in pull_dl_task(). No problem with deadline tasks balancing too.
--- kernel/sched/deadline.c | 33 ++++++++++++++++++++++++++------- 1 file changed, 26 insertions(+), 7 deletions(-)
kernel/sched/deadline.c +26 -7
@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }
@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ +static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ +raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
PATCH v2 2/3 sched/dl: Cleanup prio_changed_dl()
From: Kirill Tkhai <[email protected]>
rq->curr task can't be in "dequeued" state in prio_changed_dl(). (The only place we can have that is __schedule()). So, we delete rq->curr check.
Also delete "else" branch which is dead code (switched_to_dl() is not interested in dequeued tasks and we are not interested in balancing in this case).
--- kernel/sched/deadline.c | 50 +++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 26 deletions(-)
kernel/sched/deadline.c +24 -26
@@ -1638,35 +1638,33 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!task_on_rq_queued (p)) +return ;#ifdef CONFIG_SMP -/* -* This might be too much, but unfortunately -* we don't have the old deadline value, and -* we can't argue if the task is increasing -* or lowering its prio, so... -*/ -if (!rq->dl.overloaded) -pull_dl_task (rq); - -/* -* If we now have a earlier deadline task than p, -* then reschedule, provided p is still on this -* runqueue. -*/ -if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && - rq->curr == p) -resched_curr (rq); -#else -/* -* Again, we don't know if p has a earlier -* or later deadline, so let's blindly set a -* (maybe not needed) rescheduling point. -*/ +/* +* This might be too much, but unfortunately +* we don't have the old deadline value, and +* we can't argue if the task is increasing +* or lowering its prio, so... +*/ +if (!rq->dl.overloaded) +pull_dl_task (rq); +/* +* If we now have a earlier deadline task than p, +* then reschedule, provided p is still on this +* runqueue. +*/ +if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && + rq->curr == p)resched_curr (rq); +#else +/* +* Again, we don't know if p has a earlier +* or later deadline, so let's blindly set a +* (maybe not needed) rescheduling point. +*/ +resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); }const struct sched_class dl_sched_class = {
Peter Zijlstra
maintainerRe: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
Quoted 5 lines · Kirill Tkhai
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.
the CBS timer can throttle it right?
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 8 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for on_dl_rq():
[PATCH]sched/dl: Cleanup prio_changed_dl()
rq->curr task can't be in "dequeued" state in prio_changed_dl(). (The only place we can have that is __schedule()). So, we delete rq->curr check.
We shouldn't do balancing if deadline task is throttled too.
Also delete "else" branch which is dead code (switched_to_dl() is not interested in dequeued tasks and we are not interested in balancing in this case).
kernel/sched/deadline.c +24 -26
@@ -1638,35 +1638,33 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl)) +return ;#ifdef CONFIG_SMP -/* -* This might be too much, but unfortunately -* we don't have the old deadline value, and -* we can't argue if the task is increasing -* or lowering its prio, so... -*/ -if (!rq->dl.overloaded) -pull_dl_task (rq); - -/* -* If we now have a earlier deadline task than p, -* then reschedule, provided p is still on this -* runqueue. -*/ -if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && - rq->curr == p) -resched_curr (rq); -#else -/* -* Again, we don't know if p has a earlier -* or later deadline, so let's blindly set a -* (maybe not needed) rescheduling point. -*/ +/* +* This might be too much, but unfortunately +* we don't have the old deadline value, and +* we can't argue if the task is increasing +* or lowering its prio, so... +*/ +if (!rq->dl.overloaded) +pull_dl_task (rq); +/* +* If we now have a earlier deadline task than p, +* then reschedule, provided p is still on this +* runqueue. +*/ +if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && + rq->curr == p)resched_curr (rq); +#else +/* +* Again, we don't know if p has a earlier +* or later deadline, so let's blindly set a +* (maybe not needed) rescheduling point. +*/ +resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); }const struct sched_class dl_sched_class = {
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
Hi Kirill,
Quoted 18 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 8 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for
on_dl_rq():[PATCH]sched/dl: Cleanup
prio_changed_dl()
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.
Quoted 6 lines
We shouldn't do balancing if deadline task is throttled too.
Also delete "else" branch which is dead code (
switched_to_dl()is not interested in dequeued tasks and we are not interested in balancing in this case).
So, I agree that calling switched_to_dl() makes little sense, but don't we have to deal with updates to not running tasks as in rt.c? Something like this maybe?
Quoted 1 line
From
75ee75a5fd76526baaed3ba8a58f3ff7daa89cd6Mon Sep 17 00:00:00 2001
From: Juri Lelli <[email protected]>
Date: Tue, 21 Oct 2014 17:15:15 +0100
Subject: [PATCH] sched/deadline: cleanup prio_changed_dl()
--- kernel/sched/deadline.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
kernel/sched/deadline.c +13 -3
@@ -1661,7 +1661,10 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl)) +return ; + +if (rq->curr == p) {#ifdef CONFIG_SMP /* * This might be too much, but unfortunately
@@ -1688,8 +1691,15 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,*/ resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); + }else { +/* +* This task is not running, so if its deadline is +* now more imminent than that of the current running +* task then reschedule. +*/ +if (dl_time_before (p->dl.deadline, rq->curr->dl.deadline)) +resched_curr (rq); + } }const struct sched_class dl_sched_class = {
Signature · 5 lines
2.1.0 Thanks, - Juri
Quoted 69 lines
Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +24
-26@@ -1638,35 +1638,33 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl)) +return ;#ifdef CONFIG_SMP -/* -* This might be too much, but unfortunately -* we don't have the old deadline value, and -* we can't argue if the task is increasing -* or lowering its prio, so... -*/ -if (!rq->dl.overloaded) -pull_dl_task (rq); - -/* -* If we now have a earlier deadline task than p, -* then reschedule, provided p is still on this -* runqueue. -*/ -if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && - rq->curr == p) -resched_curr (rq); -#else -/* -* Again, we don't know if p has a earlier -* or later deadline, so let's blindly set a -* (maybe not needed) rescheduling point. -*/ +/* +* This might be too much, but unfortunately +* we don't have the old deadline value, and +* we can't argue if the task is increasing +* or lowering its prio, so... +*/ +if (!rq->dl.overloaded) +pull_dl_task (rq); +/* +* If we now have a earlier deadline task than p, +* then reschedule, provided p is still on this +* runqueue. +*/ +if (dl_time_before (rq->dl.earliest_dl.curr, p->dl.deadline) && + rq->curr == p)resched_curr (rq); +#else +/* +* Again, we don't know if p has a earlier +* or later deadline, so let's blindly set a +* (maybe not needed) rescheduling point. +*/ +resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); }const struct sched_class dl_sched_class = {
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
В Вт, 21/10/2014 в 17:24 +0100, Juri Lelli пишет:
Quoted 23 lines
Hi Kirill,
Quoted 20 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 8 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for
on_dl_rq():[PATCH]sched/dl: Cleanup
prio_changed_dl()
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.We shouldn't do balancing if deadline task is throttled too.
Quoted 8 lines
Quoted 4 lines
Also delete "else" branch which is dead code (
switched_to_dl()is not interested in dequeued tasks and we are not interested in balancing in this case).So, I agree that calling
switched_to_dl()makes little sense, but don't we have to deal with updates to not running tasks as inrt.c? Something like this maybe?
Looks good. No objections from me.
Quoted 44 lines
From
75ee75a5fd76526baaed3ba8a58f3ff7daa89cd6Mon Sep 17 00:00:00 2001
From: Juri Lelli <[email protected]>
Date: Tue, 21 Oct 2014 17:15:15 +0100
Subject: [PATCH] sched/deadline: cleanupprio_changed_dl()--- kernel/sched/deadline.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)kernel/sched/deadline.c +13
-3@@ -1661,7 +1661,10 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl)) +return ; + +if (rq->curr == p) {#ifdef CONFIG_SMP /* * This might be too much, but unfortunately @@ -1688,8 +1691,15 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,*/ resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); + }else { +/* +* This task is not running, so if its deadline is +* now more imminent than that of the current running +* task then reschedule. +*/ +if (dl_time_before (p->dl.deadline, rq->curr->dl.deadline)) +resched_curr (rq); + } }const struct sched_class dl_sched_class = {
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
Quoted 29 lines · Kirill Tkhai
В Вт, 21/10/2014 в 17:24 +0100, Juri Lelli пишет:
Quoted 28 lines
Hi Kirill,
Quoted 24 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 8 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for
on_dl_rq():[PATCH]sched/dl: Cleanup
prio_changed_dl()
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.We shouldn't do balancing if deadline task is throttled too.
Also delete "else" branch which is dead code (
switched_to_dl()is not interested in dequeued tasks and we are not interested in balancing in this case).
Quoted 6 lines
Quoted 3 lines
So, I agree that calling
switched_to_dl()makes little sense, but don't we have to deal with updates to not running tasks as inrt.c? Something like this maybe?Looks good. No objections from me.
Ok, thanks Kirill. I'll send out a proper patch soon.
Best,
- Juri
Quoted 47 lines
Quoted 44 lines
From
75ee75a5fd76526baaed3ba8a58f3ff7daa89cd6Mon Sep 17 00:00:00 2001
From: Juri Lelli <[email protected]>
Date: Tue, 21 Oct 2014 17:15:15 +0100
Subject: [PATCH] sched/deadline: cleanupprio_changed_dl()--- kernel/sched/deadline.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)kernel/sched/deadline.c +13
-3@@ -1661,7 +1661,10 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl)) +return ; + +if (rq->curr == p) {#ifdef CONFIG_SMP /* * This might be too much, but unfortunately @@ -1688,8 +1691,15 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,*/ resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); + }else { +/* +* This task is not running, so if its deadline is +* now more imminent than that of the current running +* task then reschedule. +*/ +if (dl_time_before (p->dl.deadline, rq->curr->dl.deadline)) +resched_curr (rq); + } }const struct sched_class dl_sched_class = {
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
In reply to Juri Lelli10/22/14, 12:24 AM, Juri Lelli:
Quoted 43 lines
Hi Kirill,
Quoted 16 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 7 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for
on_dl_rq():[PATCH]sched/dl: Cleanup
prio_changed_dl()
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.Quoted 6 lines
We shouldn't do balancing if deadline task is throttled too.
Also delete "else" branch which is dead code (
switched_to_dl()is not interested in dequeued tasks and we are not interested in balancing in this case).So, I agree that calling
switched_to_dl()makes little sense, but don't we have to deal with updates to not running tasks as inrt.c? Something like this maybe?From
75ee75a5fd76526baaed3ba8a58f3ff7daa89cd6Mon Sep 17 00:00:00 2001
From: Juri Lelli <[email protected]>
Date: Tue, 21 Oct 2014 17:15:15 +0100
Subject: [PATCH] sched/deadline: cleanupprio_changed_dl()--- kernel/sched/deadline.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)kernel/sched/deadline.c +0
-0
kernel/sched/deadline.c static void switched_to_dl(struct rq *rq, struct task_struct *p) · line 1664
Quoted 5 lines
kernel/sched/deadline.c +1
-1@@ -1661,7 +1661,10 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl))
I'm not sure if this should be task_on_rq_queued() check. All check_class_changed() callsites dequeue entity if task_on_rq_queued() is true which leads to on_dl_rq(&p->dl) always return false.
Regards,
Wanpeng Li
Quoted 24 lines
kernel/sched/deadline.c +12
-2+return ; + +if (rq->curr == p) {#ifdef CONFIG_SMP /* * This might be too much, but unfortunately @@ -1688,8 +1691,15 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,*/ resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); + }else { +/* +* This task is not running, so if its deadline is +* now more imminent than that of the current running +* task then reschedule. +*/ +if (dl_time_before (p->dl.deadline, rq->curr->dl.deadline)) +resched_curr (rq); + } }const struct sched_class dl_sched_class = {
Re: [PATCH v2 2/3] sched/dl: Cleanup prio_changed_dl()
Hi,
Quoted 39 lines · Wanpeng Li
10/22/14, 12:24 AM, Juri Lelli:
Quoted 38 lines
Hi Kirill,
Quoted 16 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:36 +0200, Peter Zijlstra пишет:
Quoted 7 lines · Kirill Tkhai
Quoted 5 lines
From: Kirill Tkhai <[email protected]>
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.the CBS timer can throttle it right?
Yeah, it's better to check for
on_dl_rq():[PATCH]sched/dl: Cleanup
prio_changed_dl()
rq->currtask can't be in "dequeued" state inprio_changed_dl(). (The only place we can have that is__schedule()). So, we deleterq->currcheck.Quoted 6 lines
We shouldn't do balancing if deadline task is throttled too.
Also delete "else" branch which is dead code (
switched_to_dl()is not interested in dequeued tasks and we are not interested in balancing in this case).So, I agree that calling
switched_to_dl()makes little sense, but don't we have to deal with updates to not running tasks as inrt.c? Something like this maybe?From
75ee75a5fd76526baaed3ba8a58f3ff7daa89cd6Mon Sep 17 00:00:00 2001
From: Juri Lelli <[email protected]>
Date: Tue, 21 Oct 2014 17:15:15 +0100
Subject: [PATCH] sched/deadline: cleanupprio_changed_dl()--- kernel/sched/deadline.c | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-)
Quoted 15 lines
kernel/sched/deadline.c static void switched_to_dl(struct rq *rq, struct task_struct *p) · line 1664
Quoted 10 lines
kernel/sched/deadline.c +1
-1@@ -1661,7 +1661,10 @@ static void switched_to_dl(struct rq *rq, struct task_struct *p)static void prio_changed_dl (struct rq *rq,struct task_struct *p,int oldprio) { -if (task_on_rq_queued (p) || rq->curr == p) { +if (!on_dl_rq (&p->dl))I'm not sure if this should be
task_on_rq_queued()check. Allcheck_class_changed()callsites dequeue entity iftask_on_rq_queued()is true which leads toon_dl_rq(&p->dl)always return false.
Yes, to be able to change class/prio. But they also enqueue it back if it was on_rq. So, on_dl_rq() helps us when the tasks is throttled.
Thanks,
- Juri
Quoted 29 lines
Regards,
Wanpeng LiQuoted 24 lines
kernel/sched/deadline.c +12
-2+return ; + +if (rq->curr == p) {#ifdef CONFIG_SMP /* * This might be too much, but unfortunately @@ -1688,8 +1691,15 @@ static void prio_changed_dl(struct rq *rq, struct task_struct *p,*/ resched_curr (rq);#endif /* CONFIG_SMP */ - }else -switched_to_dl (rq, p); + }else { +/* +* This task is not running, so if its deadline is +* now more imminent than that of the current running +* task then reschedule. +*/ +if (dl_time_before (p->dl.deadline, rq->curr->dl.deadline)) +resched_curr (rq); + } }const struct sched_class dl_sched_class = {
PATCH v2 3/3 sched/fair: Delete resched_cpu() from idle_balance()
In reply to Kirill TkhaiFrom: Kirill Tkhai <[email protected]>
We already reschedule env.dst_cpu in attach_tasks()->check_preempt_curr() if this is necessary.
Furthermore, a higher priority class task may be current on dest rq, we shouldn't disturb it.
--- kernel/sched/fair.c | 6 ------ 1 file changed, 6 deletions(-)
kernel/sched/fair.c +0 -6
@@ -6700,12 +6700,6 @@ static int load_balance(int this_cpu, struct rq *this_rq,local_irq_restore (flags); -/* -* some other cpu did the load balance for us. -*/ -if (cur_ld_moved && env.dst_cpu !=smp_processor_id ()) -resched_cpu (env.dst_cpu); -if (env.flags &LBF_NEED_BREAK ) { env.flags &= ~LBF_NEED_BREAK ; goto more_balance;
tip-bot for Kirill Tkhai
merge bot[tip:sched/core] sched/fair: Delete resched_cpu() from idle_balance()
sched/fair: Delete resched_cpu() from idle_balance()
Commit-ID: 10a12983b3d437a6998b3845870e52c1c752c101 Gitweb: http://git.kernel.org/tip/10a12983b3d437a6998b3845870e52c1c752c101 Author: Kirill Tkhai <[email protected]> AuthorDate: Wed, 1 Oct 2014 01:04:44 +0400 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 3 Oct 2014 05:46:56 +0200
sched/fair: Delete resched_cpu() from idle_balance()
We already reschedule env.dst_cpu in attach_tasks()->check_preempt_curr() if this is necessary.
Furthermore, a higher priority class task may be current on dest rq, we shouldn't disturb it.
--- kernel/sched/fair.c | 6 ------ 1 file changed, 6 deletions(-)
kernel/sched/fair.c +0 -6
@@ -6701,12 +6701,6 @@ more_balance:local_irq_restore (flags); -/* -* some other cpu did the load balance for us. -*/ -if (cur_ld_moved && env.dst_cpu !=smp_processor_id ()) -resched_cpu (env.dst_cpu); -if (env.flags &LBF_NEED_BREAK ) { env.flags &= ~LBF_NEED_BREAK ; goto more_balance;
Peter Zijlstra
maintainerQuoted 3 lines · Kirill Tkhai
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.
Well, not really a surprise that, its a _try_ operation after all.
Quoted 24 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...
Quoted 6 lines
So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.
That doesn't sound right. pull_dl_task() is an entirely different callchain than switched_from(). Now it might still be fine, but you cannot compare it with pull_dl_task.
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 34 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 27 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
Quoted 7 lines
Quoted 3 lines
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.
I mean that caller of switched_from_dl() already knows about this situation, and we do not limit the area of its use.
Does this sound better?
[PATCH] sched/dl: Implement cancel_dl_timer() to use in switched_from_dl()
Currently used hrtimer_try_to_cancel() is racy:
raw_spin_lock(&rq->lock)
... dl_task_timer raw_spin_lock(&rq->lock)
... raw_spin_lock(&rq->lock) ...
switched_from_dl() ... ...
hrtimer_try_to_cancel() ... ...
switched_to_fair() ... ...
... ... ...
... ... ...
raw_spin_unlock(&rq->lock) ... (asquired)
... ... ...
... ... ...
do_exit() ... ...
schedule() ... ...
raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock)
... ... ...
raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock)
... ... (asquired)
put_task_struct() ... ...
free_task_struct() ... ...
... ... raw_spin_unlock(&rq->lock)
... (asquired) ...
... ... ...
... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of switched_from_dl() use, because it already was possible in pull_dl_task() below.
kernel/sched/deadline.c +26 -7
@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }
@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ +static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ +raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 39 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 38 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 30 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.
Quoted 7 lines
Quoted 3 lines
That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.
Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
Thanks a lot,
- Juri
Quoted 95 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +26
-7@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ +static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ +raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
В Вт, 21/10/2014 в 11:30 +0100, Juri Lelli пишет:
Quoted 49 lines
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 43 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 41 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 24 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...Quoted 6 lines
So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.
Quoted 6 lines
Quoted 3 lines
I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
We have only caller of switched_from_dl(). It's check_class_changed(). This function doesn't suppose that lock is always locked during its call.
What other details you want?
Quoted 5 lines
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
No, I haven't written any tests to reproduce namely this situation. I found it by code analyzing. The same way we fixed the problem with rq change in dl_task_timer():
http://www.spinics.net/lists/stable/msg49080.html
Are you agree the race is here? It's my fix, and if brings a problem please clarify it.
I'm waiting for your reply.
Thanks,
Kirill
Quoted 96 lines
Quoted 95 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +26
-7@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ +static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ +raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
Quoted 54 lines · Kirill Tkhai
В Вт, 21/10/2014 в 11:30 +0100, Juri Lelli пишет:
Quoted 53 lines
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 46 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 34 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 27 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
Quoted 7 lines
Quoted 3 lines
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.
Quoted 8 lines
Quoted 2 lines
Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
We have only caller of
switched_from_dl(). It'scheck_class_changed(). This function doesn't suppose that lock is always locked during its call.What other details you want?
Ok, now is more clear, thanks. I was just wondering about what Peter asked. If you can detail more about why we are still fine with it, instead that just "it already was possible in pull_dl_task() below", that would be nice to have.
Also, check_class_changed() is called from several places (rt_mutex_setprio() for example), are we fine with all this callplaces as well?
Quoted 6 lines
Quoted 5 lines
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
Quoted 6 lines
No, I haven't written any tests to reproduce namely this situation. I found it by code analyzing. The same way we fixed the problem with rq change in
dl_task_timer():http://www.spinics.net/lists/stable/msg49080.html
Yeah, but I did write a test for that race:
"Juri Lelli reports he got this race when dl_bandwidth_enabled()
was not set."
And after that I felt more confident about the change :).
Quoted 3 lines
Are you agree the race is here? It's my fix, and if brings a problem please clarify it.
Yeah, it seems that the race may happen. I'm just saying that it would be nice to see it happening before we fix the thing. I wish I have some time to try to setup a test. Even if I can't spot any problems with your patch, apart from small comments below, not being completely confident that this doesn't introduce regression elsewhere brought me to ask from more details.
Quoted 62 lines
I'm waiting for your reply.
Thanks,
KirillQuoted 57 lines
Quoted 57 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +0
-5@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)
Quoted 5 lines
Quoted 5 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1567
Quoted 5 lines
kernel/sched/deadline.c +3
-0#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/
Maybe we can add comments explaining why we are fine releasing the lock here.
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
kernel/sched/deadline.c +7
-0+static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); +
Quoted 8 lines
Quoted 8 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1582
Quoted 8 lines
kernel/sched/deadline.c +8
-0+if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/
Yeah, some comments also here on why this is all good?
Thanks a lot Kirill!
Best,
- Juri
Quoted 22 lines
Quoted 19 lines
Quoted 18 lines
kernel/sched/deadline.c +8
-2+raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
В Вт, 21/10/2014 в 12:41 +0100, Juri Lelli пишет:
Quoted 64 lines · Kirill Tkhai
Quoted 54 lines
В Вт, 21/10/2014 в 11:30 +0100, Juri Lelli пишет:
Quoted 53 lines
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 46 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 34 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 27 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
Quoted 7 lines
Quoted 3 lines
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.Quoted 8 lines
Quoted 2 lines
Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
We have only caller of
switched_from_dl(). It'scheck_class_changed(). This function doesn't suppose that lock is always locked during its call.What other details you want?
Quoted 8 lines
Ok, now is more clear, thanks. I was just wondering about what Peter asked. If you can detail more about why we are still fine with it, instead that just "it already was possible in
pull_dl_task()below", that would be nice to have.Also,
check_class_changed()is called from several places (rt_mutex_setprio()for example), are we fine with all this callplaces as well?
Yeah. New code in the patch is working when hrtimer_try_to_cancel() fails. This means the callback is running. In this case hrtimer_cancel() is just waiting till the callback is finished.
Since we are in switched_from_dl(), new class is not dl_sched_class and new prio is not less MAX_DL_PRIO. So, the callback returns early just after !dl_task() check. After that hrtimer_cancel() returns back too.
The above is:
raw_spin_lock(rq->lock); ...
... dl_task_timer()
... raw_spin_lock(rq->lock);
switched_from_dl() ...
hrtimer_try_to_cancel() ...
raw_spin_unlock(rq->lock); ...
hrtimer_cancel() ...
... raw_spin_unlock(rq->lock);
... return HRTIMER_NORESTART;
... ...
raw_spin_lock(rq->lock); ... But the below is also possible:
dl_task_timer()
raw_spin_lock(rq->lock);
...
raw_spin_unlock(rq->lock);
raw_spin_lock(rq->lock); ...
switched_from_dl() ...
hrtimer_try_to_cancel() ...
... return HRTIMER_NORESTART;
raw_spin_unlock(rq->lock); ...
hrtimer_cancel(); ...
raw_spin_lock(rq->lock); ...In this case hrtimer_cancel() returns immediately. Very unlikely case, just to mention.
Nobody can manipulate the task, because check_class_changed() is always called with pi_lock locked. Nobody can force the task to participate in (concurrent) priority inheritance schemes (the same reason).
All concurrent task operations require pi_lock, which is held by us. No deadlocks with dl_task_timer() are possible, because it returns right after !dl_task() check (it does nothing).
Quoted 13 lines
Quoted 6 lines
Quoted 5 lines
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
Quoted 6 lines
No, I haven't written any tests to reproduce namely this situation. I found it by code analyzing. The same way we fixed the problem with rq change in
dl_task_timer():http://www.spinics.net/lists/stable/msg49080.html
Quoted 6 lines
Yeah, but I did write a test for that race:
"Juri Lelli reports he got this race when
dl_bandwidth_enabled()
was not set."And after that I felt more confident about the change :).
Ok, good. I forgot.
Quoted 10 lines
Quoted 3 lines
Are you agree the race is here? It's my fix, and if brings a problem please clarify it.
Yeah, it seems that the race may happen. I'm just saying that it would be nice to see it happening before we fix the thing. I wish I have some time to try to setup a test. Even if I can't spot any problems with your patch, apart from small comments below, not being completely confident that this doesn't introduce regression elsewhere brought me to ask from more details.
Sadly, I have no time to write a test for this bug. I can change the comment and add the description I posted above. Or I can add more description if you say what should be added else.
Quoted 119 lines
Quoted 63 lines
I'm waiting for your reply.
Thanks,
KirillQuoted 57 lines
Quoted 57 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +0
-5@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)Quoted 5 lines
Quoted 5 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1567
Quoted 5 lines
kernel/sched/deadline.c +3
-0#endif /* CONFIG_SMP */ +/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ Maybe we can add comments explaining why we are fine releasing the lock here.
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
kernel/sched/deadline.c +7
-0+static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); +Quoted 8 lines
Quoted 8 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1582
Quoted 8 lines
kernel/sched/deadline.c +8
-0+if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); + +if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ Yeah, some comments also here on why this is all good?
Thanks a lot Kirill!
Best,
- Juri
Quoted 22 lines
Quoted 19 lines
Quoted 18 lines
kernel/sched/deadline.c +8
-2+raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
Quoted 114 lines · Kirill Tkhai
В Вт, 21/10/2014 в 12:41 +0100, Juri Lelli пишет:
Quoted 64 lines · Kirill Tkhai
Quoted 54 lines
В Вт, 21/10/2014 в 11:30 +0100, Juri Lelli пишет:
Quoted 53 lines
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 46 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 34 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 27 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
Quoted 7 lines
Quoted 3 lines
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.Quoted 8 lines
Quoted 2 lines
Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
We have only caller of
switched_from_dl(). It'scheck_class_changed(). This function doesn't suppose that lock is always locked during its call.What other details you want?
Quoted 8 lines
Ok, now is more clear, thanks. I was just wondering about what Peter asked. If you can detail more about why we are still fine with it, instead that just "it already was possible in
pull_dl_task()below", that would be nice to have.Also,
check_class_changed()is called from several places (rt_mutex_setprio()for example), are we fine with all this callplaces as well?Yeah. New code in the patch is working when
hrtimer_try_to_cancel()fails. This means the callback is running. In this casehrtimer_cancel()is just waiting till the callback is finished.Since we are in
switched_from_dl(), new class is notdl_sched_classand new prio is not lessMAX_DL_PRIO. So, the callback returns early just after !dl_task() check. After thathrtimer_cancel()returns back too.The above is:
raw_spin_lock(rq->lock); ...
...dl_task_timer()... raw_spin_lock(rq->lock); switched_from_dl() ... hrtimer_try_to_cancel() ... raw_spin_unlock(rq->lock); ... hrtimer_cancel() ... ... raw_spin_unlock(rq->lock); ... return HRTIMER_NORESTART; ... ... raw_spin_lock(rq->lock); ...But the below is also possible:
dl_task_timer() raw_spin_lock(rq->lock); ... raw_spin_unlock(rq->lock); raw_spin_lock(rq->lock); ... switched_from_dl() ... hrtimer_try_to_cancel() ... ... return HRTIMER_NORESTART; raw_spin_unlock(rq->lock); ... hrtimer_cancel(); ... raw_spin_lock(rq->lock); ...In this case
hrtimer_cancel()returns immediately. Very unlikely case, just to mention.
Quoted 8 lines
Nobody can manipulate the task, because
check_class_changed()is always called withpi_locklocked. Nobody can force the task to participate in (concurrent) priority inheritance schemes (the same reason).All concurrent task operations require
pi_lock, which is held by us. No deadlocks withdl_task_timer()are possible, because it returns right after !dl_task() check (it does nothing).
Ok, it looks right to me. It would be nice to have what above and the original explanation of the bug in the changelog.
Quoted 33 lines
Quoted 13 lines
Quoted 6 lines
Quoted 5 lines
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
Quoted 6 lines
No, I haven't written any tests to reproduce namely this situation. I found it by code analyzing. The same way we fixed the problem with rq change in
dl_task_timer():http://www.spinics.net/lists/stable/msg49080.htmlQuoted 6 lines
Yeah, but I did write a test for that race:
"Juri Lelli reports he got this race when
dl_bandwidth_enabled()
was not set."And after that I felt more confident about the change :).
Ok, good. I forgot.
Quoted 10 lines
Quoted 3 lines
Are you agree the race is here? It's my fix, and if brings a problem please clarify it.
Yeah, it seems that the race may happen. I'm just saying that it would be nice to see it happening before we fix the thing. I wish I have some time to try to setup a test. Even if I can't spot any problems with your patch, apart from small comments below, not being completely confident that this doesn't introduce regression elsewhere brought me to ask from more details.
Quoted 4 lines
Sadly, I have no time to write a test for this bug. I can change the comment and add the description I posted above. Or I can add more description if you say what should be added else.
So, if you are ok with it, I'd say I can take some time to do a little testing anyway, as the bug is there, but nobody (except you) noticed that yet :).
Quoted 65 lines
Quoted 65 lines
Quoted 65 lines
I'm waiting for your reply.
Thanks,
KirillQuoted 59 lines
Quoted 59 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +0
-5@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */
Quoted 7 lines
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1567
Quoted 3 lines
kernel/sched/deadline.c +3
-0+/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ Maybe we can add comments explaining why we are fine releasing the lock here.
Does "Ensure p's dl_timer is cancelled. May drop rq->lock." sound better?
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
kernel/sched/deadline.c +10
-0+static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); +
Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1582
Quoted 5 lines
kernel/sched/deadline.c +5
-0+if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ Yeah, some comments also here on why this is all good?
Here you say what may happen. Can you add something saying why we are fine with this happening? Just for future reference...
Thanks again!
Best,
- Juri
Quoted 32 lines
Quoted 29 lines
Thanks a lot Kirill!
Best,
- Juri
Quoted 22 lines
Quoted 19 lines
Quoted 18 lines
kernel/sched/deadline.c +8
-2+raw_spin_unlock (&rq->lock); +hrtimer_cancel (dl_timer); +raw_spin_lock (&rq->lock); + } + } +} +static void switched_from_dl (struct rq *rq,struct task_struct *p) { -if (hrtimer_active (&p->dl.dl_timer) && !dl_policy (p->policy)) -hrtimer_try_to_cancel (&p->dl.dl_timer); +cancel_dl_timer (rq, p);__dl_clear_params (p);
В Ср, 22/10/2014 в 11:00 +0100, Juri Lelli пишет:
Quoted 119 lines · Kirill Tkhai
Quoted 118 lines
В Вт, 21/10/2014 в 12:41 +0100, Juri Lelli пишет:
Quoted 64 lines · Kirill Tkhai
Quoted 54 lines
В Вт, 21/10/2014 в 11:30 +0100, Juri Lelli пишет:
Quoted 53 lines
Hi Kirill,
sorry for the late reply, but I was busy doing other stuff and then travelling.
Quoted 46 lines · Kirill Tkhai
В Чт, 02/10/2014 в 11:34 +0200, Peter Zijlstra пишет:
Quoted 34 lines · Kirill Tkhai
Quoted 3 lines
From: Kirill Tkhai <[email protected]>
hrtimer_try_to_cancel()may bring a suprise, its call may fail.Well, not really a surprise that, its a _try_ operation after all.
Quoted 27 lines
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... Surprise!!! ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
Quoted 7 lines
Quoted 3 lines
We do not create any problem with rq unlocking, because it already may happed below in
pull_dl_task(). No problem with deadline tasks balancing too.That doesn't sound right.
pull_dl_task()is an entirely different callchain thanswitched_from(). Now it might still be fine, but you cannot compare it withpull_dl_task.I mean that caller of
switched_from_dl()already knows about this situation, and we do not limit the area of its use.Quoted 8 lines
Quoted 2 lines
Not sure what you mean with "the caller already knows...". Also, can you detail more about the different callchains?
We have only caller of
switched_from_dl(). It'scheck_class_changed(). This function doesn't suppose that lock is always locked during its call.What other details you want?
Quoted 8 lines
Ok, now is more clear, thanks. I was just wondering about what Peter asked. If you can detail more about why we are still fine with it, instead that just "it already was possible in
pull_dl_task()below", that would be nice to have.Also,
check_class_changed()is called from several places (rt_mutex_setprio()for example), are we fine with all this callplaces as well?Yeah. New code in the patch is working when
hrtimer_try_to_cancel()fails. This means the callback is running. In this casehrtimer_cancel()is just waiting till the callback is finished.Since we are in
switched_from_dl(), new class is notdl_sched_classand new prio is not lessMAX_DL_PRIO. So, the callback returns early just after !dl_task() check. After thathrtimer_cancel()returns back too.The above is:
raw_spin_lock(rq->lock); ...
...dl_task_timer()... raw_spin_lock(rq->lock); switched_from_dl() ... hrtimer_try_to_cancel() ... raw_spin_unlock(rq->lock); ... hrtimer_cancel() ... ... raw_spin_unlock(rq->lock); ... return HRTIMER_NORESTART; ... ... raw_spin_lock(rq->lock); ...But the below is also possible:
dl_task_timer() raw_spin_lock(rq->lock); ... raw_spin_unlock(rq->lock); raw_spin_lock(rq->lock); ... switched_from_dl() ... hrtimer_try_to_cancel() ... ... return HRTIMER_NORESTART; raw_spin_unlock(rq->lock); ... hrtimer_cancel(); ... raw_spin_lock(rq->lock); ...In this case
hrtimer_cancel()returns immediately. Very unlikely case, just to mention.Nobody can manipulate the task, because
check_class_changed()is always called withpi_locklocked. Nobody can force the task to participate in (concurrent) priority inheritance schemes (the same reason).
Quoted 7 lines
Quoted 4 lines
All concurrent task operations require
pi_lock, which is held by us. No deadlocks withdl_task_timer()are possible, because it returns right after !dl_task() check (it does nothing).Ok, it looks right to me. It would be nice to have what above and the original explanation of the bug in the changelog.
I'll send new patch with your remarks.
Quoted 136 lines
Quoted 33 lines
Quoted 13 lines
Quoted 6 lines
Quoted 5 lines
Do you have any test for this situation? Do you experienced any crash? As you know, the replenishment timer is of key importance for us, and I'd like to be 100% sure we don't introduce any problems with this change :).
Quoted 6 lines
No, I haven't written any tests to reproduce namely this situation. I found it by code analyzing. The same way we fixed the problem with rq change in
dl_task_timer():http://www.spinics.net/lists/stable/msg49080.htmlQuoted 6 lines
Yeah, but I did write a test for that race:
"Juri Lelli reports he got this race when
dl_bandwidth_enabled()
was not set."And after that I felt more confident about the change :).
Ok, good. I forgot.
Quoted 10 lines
Quoted 3 lines
Are you agree the race is here? It's my fix, and if brings a problem please clarify it.
Yeah, it seems that the race may happen. I'm just saying that it would be nice to see it happening before we fix the thing. I wish I have some time to try to setup a test. Even if I can't spot any problems with your patch, apart from small comments below, not being completely confident that this doesn't introduce regression elsewhere brought me to ask from more details.
Quoted 4 lines
Sadly, I have no time to write a test for this bug. I can change the comment and add the description I posted above. Or I can add more description if you say what should be added else.
So, if you are ok with it, I'd say I can take some time to do a little testing anyway, as the bug is there, but nobody (except you) noticed that yet :).
Quoted 65 lines
Quoted 65 lines
Quoted 65 lines
I'm waiting for your reply.
Thanks,
KirillQuoted 59 lines
Quoted 59 lines
Does this sound better?
[PATCH] sched/dl: Implement
cancel_dl_timer()to use inswitched_from_dl()Currently used
hrtimer_try_to_cancel()is racy:
raw_spin_lock(&rq->lock)... dl_task_timer raw_spin_lock(&rq->lock) ... raw_spin_lock(&rq->lock) ... switched_from_dl() ... ... hrtimer_try_to_cancel() ... ... switched_to_fair() ... ... ... ... ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... ... do_exit() ... ... schedule() ... ... raw_spin_lock(&rq->lock) ... raw_spin_unlock(&rq->lock) ... ... ... raw_spin_unlock(&rq->lock) ... raw_spin_lock(&rq->lock) ... ... (asquired) put_task_struct() ... ... free_task_struct() ... ... ... ... raw_spin_unlock(&rq->lock) ... (asquired) ... ... ... ... ... (use after free) ...So, let's implement 100% guaranteed way to cancel the timer and let's be sure we are safe even in very unlikely situations.
rq unlocking does not limit the area of
switched_from_dl()use, because it already was possible inpull_dl_task()below.Signed-off-by Kirill Tkhai <[email protected]>kernel/sched/deadline.c +0
-5@@ -555,11 +555,6 @@ void init_dl_task_timer(struct sched_dl_entity *dl_se) {struct hrtimer *timer = &dl_se->dl_timer; -if (hrtimer_active (timer)) { -hrtimer_try_to_cancel (timer); -return ; - } -hrtimer_init (timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); timer->function = dl_task_timer; }@@ -1567,10 +1562,34 @@ void init_sched_dl_class(void)#endif /* CONFIG_SMP */ Quoted 7 lines
Quoted 7 lines
Quoted 3 lines
Quoted 3 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1567
Quoted 3 lines
kernel/sched/deadline.c +3
-0+/* +* Surely cancel task's dl_timer. May drop rq->lock. +*/ Maybe we can add comments explaining why we are fine releasing the lock here.
Does "Ensure p's
dl_timeris cancelled. May droprq->lock." sound better?Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
Quoted 10 lines
kernel/sched/deadline.c +10
-0+static void cancel_dl_timer (struct rq *rq,struct task_struct *p) +{ +struct hrtimer *dl_timer = &p->dl.dl_timer; + +/* Nobody will change task's class if pi_lock is held */ +lockdep_assert_held (&p->pi_lock); + +if (hrtimer_active (dl_timer)) { +int ret =hrtimer_try_to_cancel (dl_timer); +Quoted 8 lines
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
kernel/sched/deadline.c void init_sched_dl_class(void) · line 1582
Quoted 5 lines
kernel/sched/deadline.c +5
-0+if (unlikely (ret ==-1 )) { +/* +* Note, p may migrate OR new deadline tasks +* may appear in rq when we are unlocking it. +*/ Yeah, some comments also here on why this is all good?
Quoted 2 lines
Here you say what may happen. Can you add something saying why we are fine with this happening? Just for future reference...
Thanks!
Kirill