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

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

Revert "sched/deadline: Fix priority inheritance with multiple scheduling classes" 



This reverts commit 3cc3d77d which is
commit 2279f540ea7d05f22d2f0c4224319330228586bc upstream.

It breaks the Android ABI and is not needed in Android systems, so
revert it for now.  If it is still needed, it can be added back later in
an ABI-stable way.

Bug: 161946584
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@google.com>
Change-Id: If069cb7d8460c5a00180a45085365747ffb8a8e7
parent 24a01b22

include/linux/sched.h

+1 −9
Original line number Diff line number Diff line
@@ -565,6 +565,7 @@ struct sched_dl_entity { 
	 * overruns.

	 */

	unsigned int			dl_throttled      : 1;

	unsigned int			dl_boosted        : 1;

	unsigned int			dl_yielded        : 1;

	unsigned int			dl_non_contending : 1;

	unsigned int			dl_overrun	  : 1;
@@ -583,15 +584,6 @@ struct sched_dl_entity { 
	 * time.

	 */

	struct hrtimer inactive_timer;



#ifdef CONFIG_RT_MUTEXES

	/*

	 * Priority Inheritance. When a DEADLINE scheduling entity is boosted

	 * pi_se points to the donor, otherwise points to the dl_se it belongs

	 * to (the original one/itself).

	 */

	struct sched_dl_entity *pi_se;

#endif

};



#ifdef CONFIG_UCLAMP_TASK

kernel/sched/core.c

+5 −6
Original line number Diff line number Diff line
@@ -4478,21 +4478,20 @@ void rt_mutex_setprio(struct task_struct *p, struct task_struct *pi_task) 
		if (!dl_prio(p->normal_prio) ||

		    (pi_task && dl_prio(pi_task->prio) &&

		     dl_entity_preempt(&pi_task->dl, &p->dl))) {

			p->dl.pi_se = pi_task->dl.pi_se;

			p->dl.dl_boosted = 1;

			queue_flag |= ENQUEUE_REPLENISH;

		} else {

			p->dl.pi_se = &p->dl;

		}

		} else

			p->dl.dl_boosted = 0;

		p->sched_class = &dl_sched_class;

	} else if (rt_prio(prio)) {

		if (dl_prio(oldprio))

			p->dl.pi_se = &p->dl;

			p->dl.dl_boosted = 0;

		if (oldprio < prio)

			queue_flag |= ENQUEUE_HEAD;

		p->sched_class = &rt_sched_class;

	} else {

		if (dl_prio(oldprio))

			p->dl.pi_se = &p->dl;

			p->dl.dl_boosted = 0;

		if (rt_prio(oldprio))

			p->rt.timeout = 0;

		p->sched_class = &fair_sched_class;

kernel/sched/deadline.c

+44 −53
Original line number Diff line number Diff line
@@ -43,28 +43,6 @@ static inline int on_dl_rq(struct sched_dl_entity *dl_se) 
	return !RB_EMPTY_NODE(&dl_se->rb_node);

}



#ifdef CONFIG_RT_MUTEXES

static inline struct sched_dl_entity *pi_of(struct sched_dl_entity *dl_se)

{

	return dl_se->pi_se;

}



static inline bool is_dl_boosted(struct sched_dl_entity *dl_se)

{

	return pi_of(dl_se) != dl_se;

}

#else

static inline struct sched_dl_entity *pi_of(struct sched_dl_entity *dl_se)

{

	return dl_se;

}



static inline bool is_dl_boosted(struct sched_dl_entity *dl_se)

{

	return false;

}

#endif



#ifdef CONFIG_SMP

static inline struct dl_bw *dl_bw_of(int i)

{
@@ -679,7 +657,7 @@ static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se) 
	struct dl_rq *dl_rq = dl_rq_of_se(dl_se);

	struct rq *rq = rq_of_dl_rq(dl_rq);



	WARN_ON(is_dl_boosted(dl_se));

	WARN_ON(dl_se->dl_boosted);

	WARN_ON(dl_time_before(rq_clock(rq), dl_se->deadline));



	/*
@@ -717,20 +695,21 @@ static inline void setup_new_dl_entity(struct sched_dl_entity *dl_se) 
 * could happen are, typically, a entity voluntarily trying to overcome its

 * runtime, or it just underestimated it during sched_setattr().

 */

static void replenish_dl_entity(struct sched_dl_entity *dl_se)

static void replenish_dl_entity(struct sched_dl_entity *dl_se,

				struct sched_dl_entity *pi_se)

{

	struct dl_rq *dl_rq = dl_rq_of_se(dl_se);

	struct rq *rq = rq_of_dl_rq(dl_rq);



	BUG_ON(pi_of(dl_se)->dl_runtime <= 0);

	BUG_ON(pi_se->dl_runtime <= 0);



	/*

	 * This could be the case for a !-dl task that is boosted.

	 * Just go with full inherited parameters.

	 */

	if (dl_se->dl_deadline == 0) {

		dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;

		dl_se->runtime = pi_of(dl_se)->dl_runtime;

		dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;

		dl_se->runtime = pi_se->dl_runtime;

	}



	if (dl_se->dl_yielded && dl_se->runtime > 0)
@@ -743,8 +722,8 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se) 
	 * arbitrary large.

	 */

	while (dl_se->runtime <= 0) {

		dl_se->deadline += pi_of(dl_se)->dl_period;

		dl_se->runtime += pi_of(dl_se)->dl_runtime;

		dl_se->deadline += pi_se->dl_period;

		dl_se->runtime += pi_se->dl_runtime;

	}



	/*
@@ -758,8 +737,8 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se) 
	 */

	if (dl_time_before(dl_se->deadline, rq_clock(rq))) {

		printk_deferred_once("sched: DL replenish lagged too much\n");

		dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;

		dl_se->runtime = pi_of(dl_se)->dl_runtime;

		dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;

		dl_se->runtime = pi_se->dl_runtime;

	}



	if (dl_se->dl_yielded)
@@ -792,7 +771,8 @@ static void replenish_dl_entity(struct sched_dl_entity *dl_se) 
 * task with deadline equal to period this is the same of using

 * dl_period instead of dl_deadline in the equation above.

 */

static bool dl_entity_overflow(struct sched_dl_entity *dl_se, u64 t)

static bool dl_entity_overflow(struct sched_dl_entity *dl_se,

			       struct sched_dl_entity *pi_se, u64 t)

{

	u64 left, right;
@@ -814,9 +794,9 @@ static bool dl_entity_overflow(struct sched_dl_entity *dl_se, u64 t) 
	 * of anything below microseconds resolution is actually fiction

	 * (but still we want to give the user that illusion >;).

	 */

	left = (pi_of(dl_se)->dl_deadline >> DL_SCALE) * (dl_se->runtime >> DL_SCALE);

	left = (pi_se->dl_deadline >> DL_SCALE) * (dl_se->runtime >> DL_SCALE);

	right = ((dl_se->deadline - t) >> DL_SCALE) *

		(pi_of(dl_se)->dl_runtime >> DL_SCALE);

		(pi_se->dl_runtime >> DL_SCALE);



	return dl_time_before(right, left);

}
@@ -901,23 +881,24 @@ static inline bool dl_is_implicit(struct sched_dl_entity *dl_se) 
 * Please refer to the comments update_dl_revised_wakeup() function to find

 * more about the Revised CBS rule.

 */

static void update_dl_entity(struct sched_dl_entity *dl_se)

static void update_dl_entity(struct sched_dl_entity *dl_se,

			     struct sched_dl_entity *pi_se)

{

	struct dl_rq *dl_rq = dl_rq_of_se(dl_se);

	struct rq *rq = rq_of_dl_rq(dl_rq);



	if (dl_time_before(dl_se->deadline, rq_clock(rq)) ||

	    dl_entity_overflow(dl_se, rq_clock(rq))) {

	    dl_entity_overflow(dl_se, pi_se, rq_clock(rq))) {



		if (unlikely(!dl_is_implicit(dl_se) &&

			     !dl_time_before(dl_se->deadline, rq_clock(rq)) &&

			     !is_dl_boosted(dl_se))) {

			     !dl_se->dl_boosted)){

			update_dl_revised_wakeup(dl_se, rq);

			return;

		}



		dl_se->deadline = rq_clock(rq) + pi_of(dl_se)->dl_deadline;

		dl_se->runtime = pi_of(dl_se)->dl_runtime;

		dl_se->deadline = rq_clock(rq) + pi_se->dl_deadline;

		dl_se->runtime = pi_se->dl_runtime;

	}

}
@@ -1016,7 +997,7 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer) 
	 * The task might have been boosted by someone else and might be in the

	 * boosting/deboosting path, its not throttled.

	 */

	if (is_dl_boosted(dl_se))

	if (dl_se->dl_boosted)

		goto unlock;



	/*
@@ -1044,7 +1025,7 @@ static enum hrtimer_restart dl_task_timer(struct hrtimer *timer) 
	 * but do not enqueue -- wait for our wakeup to do that.

	 */

	if (!task_on_rq_queued(p)) {

		replenish_dl_entity(dl_se);

		replenish_dl_entity(dl_se, dl_se);

		goto unlock;

	}
@@ -1134,7 +1115,7 @@ static inline void dl_check_constrained_dl(struct sched_dl_entity *dl_se) 


	if (dl_time_before(dl_se->deadline, rq_clock(rq)) &&

	    dl_time_before(rq_clock(rq), dl_next_period(dl_se))) {

		if (unlikely(is_dl_boosted(dl_se) || !start_dl_timer(p)))

		if (unlikely(dl_se->dl_boosted || !start_dl_timer(p)))

			return;

		dl_se->dl_throttled = 1;

		if (dl_se->runtime > 0)
@@ -1265,7 +1246,7 @@ static void update_curr_dl(struct rq *rq) 
			dl_se->dl_overrun = 1;



		__dequeue_task_dl(rq, curr, 0);

		if (unlikely(is_dl_boosted(dl_se) || !start_dl_timer(curr)))

		if (unlikely(dl_se->dl_boosted || !start_dl_timer(curr)))

			enqueue_task_dl(rq, curr, ENQUEUE_REPLENISH);



		if (!is_leftmost(curr, &rq->dl))
@@ -1459,7 +1440,8 @@ static void __dequeue_dl_entity(struct sched_dl_entity *dl_se) 
}



static void

enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags)

enqueue_dl_entity(struct sched_dl_entity *dl_se,

		  struct sched_dl_entity *pi_se, int flags)

{

	BUG_ON(on_dl_rq(dl_se));
@@ -1470,9 +1452,9 @@ enqueue_dl_entity(struct sched_dl_entity *dl_se, int flags) 
	 */

	if (flags & ENQUEUE_WAKEUP) {

		task_contending(dl_se, flags);

		update_dl_entity(dl_se);

		update_dl_entity(dl_se, pi_se);

	} else if (flags & ENQUEUE_REPLENISH) {

		replenish_dl_entity(dl_se);

		replenish_dl_entity(dl_se, pi_se);

	} else if ((flags & ENQUEUE_RESTORE) &&

		  dl_time_before(dl_se->deadline,

				 rq_clock(rq_of_dl_rq(dl_rq_of_se(dl_se))))) {
@@ -1489,7 +1471,19 @@ static void dequeue_dl_entity(struct sched_dl_entity *dl_se) 


static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags)

{

	if (is_dl_boosted(&p->dl)) {

	struct task_struct *pi_task = rt_mutex_get_top_task(p);

	struct sched_dl_entity *pi_se = &p->dl;



	/*

	 * Use the scheduling parameters of the top pi-waiter task if:

	 * - we have a top pi-waiter which is a SCHED_DEADLINE task AND

	 * - our dl_boosted is set (i.e. the pi-waiter's (absolute) deadline is

	 *   smaller than our deadline OR we are a !SCHED_DEADLINE task getting

	 *   boosted due to a SCHED_DEADLINE pi-waiter).

	 * Otherwise we keep our runtime and deadline.

	 */

	if (pi_task && dl_prio(pi_task->normal_prio) && p->dl.dl_boosted) {

		pi_se = &pi_task->dl;

		/*

		 * Because of delays in the detection of the overrun of a

		 * thread's runtime, it might be the case that a thread
@@ -1522,7 +1516,7 @@ static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags) 
		 * the throttle.

		 */

		p->dl.dl_throttled = 0;

		BUG_ON(!is_dl_boosted(&p->dl) || flags != ENQUEUE_REPLENISH);

		BUG_ON(!p->dl.dl_boosted || flags != ENQUEUE_REPLENISH);

		return;

	}
@@ -1559,7 +1553,7 @@ static void enqueue_task_dl(struct rq *rq, struct task_struct *p, int flags) 
		return;

	}



	enqueue_dl_entity(&p->dl, flags);

	enqueue_dl_entity(&p->dl, pi_se, flags);



	if (!task_current(rq, p) && p->nr_cpus_allowed > 1)

		enqueue_pushable_dl_task(rq, p);
@@ -2722,14 +2716,11 @@ void __dl_clear_params(struct task_struct *p) 
	dl_se->dl_bw			= 0;

	dl_se->dl_density		= 0;



	dl_se->dl_boosted		= 0;

	dl_se->dl_throttled		= 0;

	dl_se->dl_yielded		= 0;

	dl_se->dl_non_contending	= 0;

	dl_se->dl_overrun		= 0;



#ifdef CONFIG_RT_MUTEXES

	dl_se->pi_se			= dl_se;

#endif

}



bool dl_param_changed(struct task_struct *p, const struct sched_attr *attr)