scheduler fixes
Linus,
Please pull the latest sched-urgent-for-linus git tree from:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip.git sched-urgent-for-linus
# HEAD: 2636ed5f8d15ff9395731593537b4b3fdf2af24d sched/rt: Avoid obvious configuration fail
This tree contains misc fixes: preempt_schedule_common() and io_schedule() recursion fixes, sched/dl fixes, a completion_done() revert, two sched/rt fixes and a comment update patch.
Thanks,
Ingo
------------------>
Frederic Weisbecker (1):
sched: Fix preempt_schedule_common() triggering tracing recursion
Kirill Tkhai (2):
sched/dl: Prevent enqueue of a sleeping task in dl_task_timer() sched/dl: Do update_rq_clock() in yield_task_dl()
NeilBrown (1):
sched: Prevent recursion in io_schedule()
Oleg Nesterov (1):
sched/completion: Serialize completion_done() with complete()
Peter Zijlstra (4):
sched: Clarify ordering between task_rq_lock() and move_queued_task()
sched: Make dl_task_time() use task_rq_lock() sched/autogroup: Fix failure to set cpu.rt_runtime_us sched/rt: Avoid obvious configuration fail
include/linux/sched.h | 10 ++-- kernel/sched/auto_group.c | 6 +-- kernel/sched/completion.c | 19 +++++++- kernel/sched/core.c | 113 ++++++++++++---------------------------------- kernel/sched/deadline.c | 33 ++++++++++---- kernel/sched/sched.h | 76 +++++++++++++++++++++++++++++++ 6 files changed, 155 insertions(+), 102 deletions(-)
include/linux/sched.h +7 -3
@@ -363,9 +363,6 @@ extern void show_regs(struct pt_regs *);*/ extern void show_stack (struct task_struct *task,unsigned long *sp); -void io_schedule (void ); -long io_schedule_timeout (long timeout); -extern void cpu_init (void );extern void trap_init (void );extern void update_process_times (int user);
@@ -422,6 +419,13 @@ extern signed long schedule_timeout_uninterruptible(signed long timeout); asmlinkage void schedule(void);extern void schedule_preempt_disabled (void ); +extern long io_schedule_timeout (long timeout); + +static inline void io_schedule (void ) +{ +io_schedule_timeout (MAX_SCHEDULE_TIMEOUT ); +} +struct nsproxy ;struct user_namespace ;
kernel/sched/auto_group.c +1 -5
@@ -87,8 +87,7 @@ static inline struct autogroup *autogroup_create(void)* so we don't have to move tasks around upon policy change, * or flail around trying to allocate bandwidth on the fly. * A bandwidth exception in __sched_setscheduler() allows -* the policy change to proceed. Thereafter, task_group() -* returns &root_task_group, so zero bandwidth is required. +* the policy change to proceed. */ free_rt_sched_group (tg); tg->rt_se = root_task_group.rt_se;
@@ -115,9 +114,6 @@ bool task_wants_autogroup(struct task_struct *p, struct task_group *tg)if (tg != &root_task_group)return false; -if (p->sched_class != &fair_sched_class) -return false; -/* * We can only assume the task group can't go away on us if * autogroup_move_group() can see us on ->thread_group list.
kernel/sched/completion.c +17 -2
@@ -274,7 +274,7 @@ bool try_wait_for_completion(struct completion *x)* first without taking the lock so we can * return early in the blocking case. */ -if (!ACCESS_ONCE (x->done)) +if (!READ_ONCE (x->done))return 0 ;spin_lock_irqsave (&x->wait.lock, flags);
@@ -297,6 +297,21 @@ EXPORT_SYMBOL(try_wait_for_completion);*/ bool completion_done (struct completion *x) { -return !!ACCESS_ONCE (x->done); +if (!READ_ONCE (x->done)) +return false; + +/* +* If ->done, we need to wait for complete() to release ->wait.lock +* otherwise we can end up freeing the completion before complete() +* is done referencing it. +* +* The RMB pairs with complete()'s RELEASE of ->wait.lock and orders +* the loads of ->done and ->wait.lock such that we cannot observe +* the lock before complete() acquires it while observing the ->done +* after it's acquired the lock. +*/ +smp_rmb (); +spin_unlock_wait (&x->wait.lock); +return true; }EXPORT_SYMBOL (completion_done);
kernel/sched/core.c +30 -83
160 lines not on this page · raw message
kernel/sched/deadline.c +24 -9
@@ -511,16 +511,10 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer) struct sched_dl_entity, dl_timer);struct task_struct *p =dl_task_of (dl_se); +unsigned long flags;struct rq *rq; -again: - rq =task_rq (p); -raw_spin_lock (&rq->lock); -if (rq !=task_rq (p)) { -/* Task was moved, retrying. */ -raw_spin_unlock (&rq->lock); - goto again; - } + rq =task_rq_lock (current, &flags);/* * We need to take care of several possible races here:
@@ -541,6 +535,26 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)sched_clock_tick ();update_rq_clock (rq); + +/* +* If the throttle happened during sched-out; like: +* +* schedule() +* deactivate_task() +* dequeue_task_dl() +* update_curr_dl() +* start_dl_timer() +* __dequeue_task_dl() +* prev->on_rq = 0; +* +* We can be both throttled and !queued. Replenish the counter +* but do not enqueue -- wait for our wakeup to do that. +*/ +if (!task_on_rq_queued (p)) { +replenish_dl_entity (dl_se, dl_se); + goto unlock; + } +enqueue_task_dl (rq, p,ENQUEUE_REPLENISH );if (dl_task (rq->curr))check_preempt_curr_dl (rq, p,0 );
@@ -555,7 +569,7 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer)push_dl_task (rq);#endif unlock: -raw_spin_unlock (&rq->lock); +task_rq_unlock (rq, current, &flags);return HRTIMER_NORESTART ; }
@@ -898,6 +912,7 @@ static void yield_task_dl(struct rq *rq) rq->curr->dl.dl_yielded =1 ; p->dl.runtime =0 ; } +update_rq_clock (rq);update_curr_dl (rq); }
kernel/sched/sched.h +76 -0
82 lines not on this page · raw message