Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8c36c851 authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Revert "Revert "sched: Rework pick_next_task() slow-path"" 



This reverts commit 9acb7c07.

The root problem has now been fixed in 5.4-rc7, so revert this to
prevent merge issues.

Bug: 142182814
Cc: Quentin Perret <qperret@google.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
parent 0cb380b4

kernel/sched/core.c

+12 −7
Original line number Diff line number Diff line
@@ -3919,7 +3919,7 @@ pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 


		p = fair_sched_class.pick_next_task(rq, prev, rf);

		if (unlikely(p == RETRY_TASK))

			goto again;

			goto restart;



		/* Assumes fair_sched_class->next == idle_sched_class */

		if (unlikely(!p))
@@ -3928,15 +3928,20 @@ pick_next_task(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 
		return p;

	}



again:

restart:

	/*

	 * Ensure that we put DL/RT tasks before the pick loop, such that they

	 * can PULL higher prio tasks when we lower the RQ 'priority'.

	 */

	prev->sched_class->put_prev_task(rq, prev, rf);

	if (!rq->nr_running)

		newidle_balance(rq, rf);



	for_each_class(class) {

		p = class->pick_next_task(rq, prev, rf);

		if (p) {

			if (unlikely(p == RETRY_TASK))

				goto again;

		p = class->pick_next_task(rq, NULL, NULL);

		if (p)

			return p;

	}

	}



	/* The idle class should always have a runnable task: */

	BUG();

kernel/sched/deadline.c

+2 −28
Original line number Diff line number Diff line
@@ -1761,39 +1761,13 @@ pick_next_task_dl(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 
	struct task_struct *p;

	struct dl_rq *dl_rq;



	dl_rq = &rq->dl;

	WARN_ON_ONCE(prev || rf);



	if (need_pull_dl_task(rq, prev)) {

		/*

		 * This is OK, because current is on_cpu, which avoids it being

		 * picked for load-balance and preemption/IRQs are still

		 * disabled avoiding further scheduler activity on it and we're

		 * being very careful to re-start the picking loop.

		 */

		rq_unpin_lock(rq, rf);

		pull_dl_task(rq);

		rq_repin_lock(rq, rf);

		/*

		 * pull_dl_task() can drop (and re-acquire) rq->lock; this

		 * means a stop task can slip in, in which case we need to

		 * re-start task selection.

		 */

		if (rq->stop && task_on_rq_queued(rq->stop))

			return RETRY_TASK;

	}



	/*

	 * When prev is DL, we may throttle it in put_prev_task().

	 * So, we update time before we check for dl_nr_running.

	 */

	if (prev->sched_class == &dl_sched_class)

		update_curr_dl(rq);

	dl_rq = &rq->dl;



	if (unlikely(!dl_rq->dl_nr_running))

		return NULL;



	put_prev_task(rq, prev);



	dl_se = pick_next_dl_entity(rq, dl_rq);

	BUG_ON(!dl_se);

kernel/sched/fair.c

+6 −3
Original line number Diff line number Diff line
@@ -6810,7 +6810,7 @@ pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf 
		goto idle;



#ifdef CONFIG_FAIR_GROUP_SCHED

	if (prev->sched_class != &fair_sched_class)

	if (!prev || prev->sched_class != &fair_sched_class)

		goto simple;



	/*
@@ -6887,7 +6887,7 @@ pick_next_task_fair(struct rq *rq, struct task_struct *prev, struct rq_flags *rf 
	goto done;

simple:

#endif



	if (prev)

		put_prev_task(rq, prev);



	do {
@@ -6916,6 +6916,9 @@ done: __maybe_unused; 
	return p;



idle:

	if (!rf)

		return NULL;



	new_tasks = newidle_balance(rq, rf);



	/*

kernel/sched/idle.c

+3 −1
Original line number Diff line number Diff line
@@ -390,7 +390,9 @@ pick_next_task_idle(struct rq *rq, struct task_struct *prev, struct rq_flags *rf 
{

	struct task_struct *next = rq->idle;



	if (prev)

		put_prev_task(rq, prev);



	set_next_task_idle(rq, next);



	return next;

kernel/sched/rt.c

+1 −28
Original line number Diff line number Diff line
@@ -1554,38 +1554,11 @@ pick_next_task_rt(struct rq *rq, struct task_struct *prev, struct rq_flags *rf) 
	struct task_struct *p;

	struct rt_rq *rt_rq = &rq->rt;



	if (need_pull_rt_task(rq, prev)) {

		/*

		 * This is OK, because current is on_cpu, which avoids it being

		 * picked for load-balance and preemption/IRQs are still

		 * disabled avoiding further scheduler activity on it and we're

		 * being very careful to re-start the picking loop.

		 */

		rq_unpin_lock(rq, rf);

		pull_rt_task(rq);

		rq_repin_lock(rq, rf);

		/*

		 * pull_rt_task() can drop (and re-acquire) rq->lock; this

		 * means a dl or stop task can slip in, in which case we need

		 * to re-start task selection.

		 */

		if (unlikely((rq->stop && task_on_rq_queued(rq->stop)) ||

			     rq->dl.dl_nr_running))

			return RETRY_TASK;

	}



	/*

	 * We may dequeue prev's rt_rq in put_prev_task().

	 * So, we update time before rt_queued check.

	 */

	if (prev->sched_class == &rt_sched_class)

		update_curr_rt(rq);

	WARN_ON_ONCE(prev || rf);



	if (!rt_rq->rt_queued)

		return NULL;



	put_prev_task(rq, prev);



	p = _pick_next_task_rt(rq);



	set_next_task_rt(rq, p);