sched: pick and check task if double_lock_balance() unlock the rq
v2 cover sched: pick and check task if double_lock_balance() unlock the rq
Changes in v2:
* Only change the comment and coding style as suggested by Steve
Li Bin (1):
sched/deadline.c: pick and check task if double_lock_balance() unlock
the rq
Zhou Chengming (1):
sched/rt.c: pick and check task if double_lock_balance() unlock the
rq
kernel/sched/deadline.c | 55 +++++++++++++++++++++++++++---------------------- kernel/sched/rt.c | 50 +++++++++++++++++++++----------------------- 2 files changed, 54 insertions(+), 51 deletions(-)
Signature · 1 line
1.7.12.4
PATCH v2 1/2 sched/rt.c: pick and check task if double_lock_balance() unlock the rq
From: Zhou Chengming <[email protected]>
push_rt_task() pick the first pushable task and find an eligible lowest_rq, then double_lock_balance(rq, lowest_rq). So if double_lock_balance() unlock the rq (when double_lock_balance() return 1), we have to check if this task is still on the rq.
The problem is that the check conditions are not sufficient:
if (unlikely(task_rq(task) != rq ||
!cpumask_test_cpu(lowest_rq->cpu, &task->cpus_allowed) ||
task_running(rq, task) ||
!rt_task(task) ||
!task_on_rq_queued(task))) {cpu2 cpu1 cpu0push_rt_task(rq1)
pick task_A on rq1
find rq0
double_lock_balance(rq1, rq0)
unlock(rq1)
rq1 __schedule
pick task_A run
task_A sleep (dequeued)
lock(rq0)
lock(rq1)
do_above_check(task_A)
task_rq(task_A) == rq1
cpus_allowed unchanged
task_running == false
rt_task(task_A) == true
try_to_wake_up(task_A)
select_cpu = cpu3
enqueue(rq3, task_A)
task_A->on_rq = 1
task_on_rq_queued(task_A)
above_check passed, return rq0
...
migrate task_A from rq1 to rq0So we can't rely on these checks of task_A to make sure the task_A is still on the rq1, even though we hold the rq1->lock. This patch will repick the first pushable task to be sure the task is still on the rq.
--- kernel/sched/rt.c | 50 ++++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 26 deletions(-)
kernel/sched/rt.c +24 -26
@@ -1695,6 +1695,26 @@ static int find_lowest_rq(struct task_struct *task)return -1 ; } +static struct task_struct *pick_next_pushable_task (struct rq *rq) +{ +struct task_struct *p; + +if (!has_pushable_tasks (rq)) +return NULL ; + + p =plist_first_entry (&rq->rt.pushable_tasks, + struct task_struct, pushable_tasks); + +BUG_ON (rq->cpu !=task_cpu (p)); +BUG_ON (task_current (rq, p)); +BUG_ON (p->nr_cpus_allowed <=1 ); + +BUG_ON (!task_on_rq_queued (p)); +BUG_ON (!rt_task (p)); + +return p; +} +/* Will lock the rq it finds */ static struct rq *find_lock_lowest_rq (struct task_struct *task,struct rq *rq) {
@@ -1722,17 +1742,15 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)/* if the prio of this runqueue changed, try again */ if (double_lock_balance (rq, lowest_rq)) { +struct task_struct *next_task;/* * We had to unlock the run queue. In * the mean time, task could have * migrated already or had its affinity changed. -* Also make sure that it wasn't scheduled on its rq. */ -if (unlikely (task_rq (task) != rq || - !cpumask_test_cpu (lowest_rq->cpu, &task->cpus_allowed) || -task_running (rq, task) || - !rt_task (task) || - !task_on_rq_queued (task))) { + next_task =pick_next_pushable_task (rq); +if (unlikely (next_task != task || + !cpumask_test_cpu (lowest_rq->cpu, &task->cpus_allowed))) {double_unlock_balance (rq, lowest_rq); lowest_rq =NULL ;
@@ -1752,26 +1770,6 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)return lowest_rq; } -static struct task_struct *pick_next_pushable_task (struct rq *rq) -{ -struct task_struct *p; - -if (!has_pushable_tasks (rq)) -return NULL ; - - p =plist_first_entry (&rq->rt.pushable_tasks, - struct task_struct, pushable_tasks); - -BUG_ON (rq->cpu !=task_cpu (p)); -BUG_ON (task_current (rq, p)); -BUG_ON (p->nr_cpus_allowed <=1 ); - -BUG_ON (!task_on_rq_queued (p)); -BUG_ON (!rt_task (p)); - -return p; -} -/* * If the current CPU has more than one RT task, see if the non * running task can migrate over to a CPU that is running a task
Signature · 1 line
1.7.12.4
PATCH v2 2/2 sched/deadline.c: pick and check task if double_lock_balance() unlock the rq
In reply to Li Binpush_dl_task() pick the first pushable task and find an eligible lowest_rq, then double_lock_balance(rq, lowest_rq). So if double_lock_balance() unlock the rq (when double_lock_balance() return 1), we have to check if this task is still on the rq.
The problem is that the check conditions are not sufficient:
if (unlikely(task_rq(task) != rq ||
!cpumask_test_cpu(later_rq->cpu, &task->cpus_allowed) ||
task_running(rq, task) ||
!dl_task(task) ||
!task_on_rq_queued(task))) {cpu2 cpu1 cpu0push_dl_task(rq1)
pick task_A on rq1
find rq0
double_lock_balance(rq1, rq0)
unlock(rq1)
rq1 __schedule
pick task_A run
task_A sleep (dequeued)
lock(rq0)
lock(rq1)
do_above_check(task_A)
task_rq(task_A) == rq1
cpus_allowed unchanged
task_running == false
dl_task(task_A) == true
try_to_wake_up(task_A)
select_cpu = cpu3
enqueue(rq3, task_A)
task_A->on_rq = 1
task_on_rq_queued(task_A)
above_check passed, return rq0
...
migrate task_A from rq1 to rq0So we can't rely on these checks of task_A to make sure the task_A is still on the rq1, even though we hold the rq1->lock. This patch will repick the first pushable task to be sure the task is still on the rq.
--- kernel/sched/deadline.c | 55 +++++++++++++++++++++++++++---------------------- 1 file changed, 30 insertions(+), 25 deletions(-)
kernel/sched/deadline.c +30 -25
@@ -1936,6 +1936,26 @@ static int find_later_rq(struct task_struct *task)return -1 ; } +static struct task_struct *pick_next_pushable_dl_task (struct rq *rq) +{ +struct task_struct *p; + +if (!has_pushable_dl_tasks (rq)) +return NULL ; + + p =rb_entry (rq->dl.pushable_dl_tasks_root.rb_leftmost, + struct task_struct, pushable_dl_tasks); + +BUG_ON (rq->cpu !=task_cpu (p)); +BUG_ON (task_current (rq, p)); +BUG_ON (p->nr_cpus_allowed <=1 ); + +BUG_ON (!task_on_rq_queued (p)); +BUG_ON (!dl_task (p)); + +return p; +} +/* Locks the rq it finds */ static struct rq *find_lock_later_rq (struct task_struct *task,struct rq *rq) {
@@ -1965,11 +1985,16 @@ static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq)/* Retry if something changed. */ if (double_lock_balance (rq, later_rq)) { -if (unlikely (task_rq (task) != rq || - !cpumask_test_cpu (later_rq->cpu, &task->cpus_allowed) || -task_running (rq, task) || - !dl_task (task) || - !task_on_rq_queued (task))) { +struct task_struct *next_task; +/* +* We had to unlock the run queue. In +* the mean time, task could have +* migrated already or had its affinity changed. +* Also make sure that it wasn't scheduled on its rq. +*/ + next_task =pick_next_pushable_dl_task (rq); +if (unlikely (next_task != task || + !cpumask_test_cpu (later_rq->cpu, &task->cpus_allowed))) {double_unlock_balance (rq, later_rq); later_rq =NULL ;break ;
@@ -1994,26 +2019,6 @@ static struct rq *find_lock_later_rq(struct task_struct *task, struct rq *rq)return later_rq; } -static struct task_struct *pick_next_pushable_dl_task (struct rq *rq) -{ -struct task_struct *p; - -if (!has_pushable_dl_tasks (rq)) -return NULL ; - - p =rb_entry (rq->dl.pushable_dl_tasks_root.rb_leftmost, - struct task_struct, pushable_dl_tasks); - -BUG_ON (rq->cpu !=task_cpu (p)); -BUG_ON (task_current (rq, p)); -BUG_ON (p->nr_cpus_allowed <=1 ); - -BUG_ON (!task_on_rq_queued (p)); -BUG_ON (!dl_task (p)); - -return p; -} -/* * See if the non running -deadline tasks on this rq * can be sent to some other CPU where they can preempt
Signature · 1 line
1.7.12.4