Commit caec7f3d authored by Zheng Zengkai's avatar Zheng Zengkai
Browse files

Revert "sched/rt: Fix double enqueue caused by rt_effective_prio" 

hulk inclusion
category: bugfix
bugzilla: https://gitee.com/openeuler/kernel/issues/I3ZX4D


CVE: NA

--------------------------------------------------------------

sched_change_qos_group() calls __setscheduler(), but this
function is removed by this commit, revert it temporarily.
This reverts commit dcfce1f0.

Signed-off-by: default avatarZheng Zengkai <zhengzengkai@huawei.com>
parent fdc1afbd

kernel/sched/core.c

+55 −35
Original line number Diff line number Diff line
@@ -1590,18 +1590,12 @@ void deactivate_task(struct rq *rq, struct task_struct *p, int flags) 
	dequeue_task(rq, p, flags);

}



static inline int __normal_prio(int policy, int rt_prio, int nice)

/*

 * __normal_prio - return the priority that is based on the static prio

 */

static inline int __normal_prio(struct task_struct *p)

{

	int prio;



	if (dl_policy(policy))

		prio = MAX_DL_PRIO - 1;

	else if (rt_policy(policy))

		prio = MAX_RT_PRIO - 1 - rt_prio;

	else

		prio = NICE_TO_PRIO(nice);



	return prio;

	return p->static_prio;

}



/*
@@ -1613,7 +1607,15 @@ static inline int __normal_prio(int policy, int rt_prio, int nice) 
 */

static inline int normal_prio(struct task_struct *p)

{

	return __normal_prio(p->policy, p->rt_priority, PRIO_TO_NICE(p->static_prio));

	int prio;



	if (task_has_dl_policy(p))

		prio = MAX_DL_PRIO-1;

	else if (task_has_rt_policy(p))

		prio = MAX_RT_PRIO-1 - p->rt_priority;

	else

		prio = __normal_prio(p);

	return prio;

}



/*
@@ -3238,7 +3240,7 @@ int sched_fork(unsigned long clone_flags, struct task_struct *p) 
		} else if (PRIO_TO_NICE(p->static_prio) < 0)

			p->static_prio = NICE_TO_PRIO(0);



		p->prio = p->normal_prio = p->static_prio;

		p->prio = p->normal_prio = __normal_prio(p);

		set_load_weight(p, false);



		/*
@@ -4984,18 +4986,6 @@ int default_wake_function(wait_queue_entry_t *curr, unsigned mode, int wake_flag 
}

EXPORT_SYMBOL(default_wake_function);



static void __setscheduler_prio(struct task_struct *p, int prio)

{

	if (dl_prio(prio))

		p->sched_class = &dl_sched_class;

	else if (rt_prio(prio))

		p->sched_class = &rt_sched_class;

	else

		p->sched_class = &fair_sched_class;



	p->prio = prio;

}



#ifdef CONFIG_RT_MUTEXES



static inline int __rt_effective_prio(struct task_struct *pi_task, int prio)
@@ -5111,19 +5101,22 @@ void rt_mutex_setprio(struct task_struct *p, struct task_struct *pi_task) 
		} else {

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

		}

		p->sched_class = &dl_sched_class;

	} else if (rt_prio(prio)) {

		if (dl_prio(oldprio))

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

		if (oldprio < prio)

			queue_flag |= ENQUEUE_HEAD;

		p->sched_class = &rt_sched_class;

	} else {

		if (dl_prio(oldprio))

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

		if (rt_prio(oldprio))

			p->rt.timeout = 0;

		p->sched_class = &fair_sched_class;

	}



	__setscheduler_prio(p, prio);

	p->prio = prio;



	if (queued)

		enqueue_task(rq, p, queue_flag);
@@ -5356,6 +5349,35 @@ static void __setscheduler_params(struct task_struct *p, 
	set_load_weight(p, true);

}



/* Actually do priority change: must hold pi & rq lock. */

static void __setscheduler(struct rq *rq, struct task_struct *p,

			   const struct sched_attr *attr, bool keep_boost)

{

	/*

	 * If params can't change scheduling class changes aren't allowed

	 * either.

	 */

	if (attr->sched_flags & SCHED_FLAG_KEEP_PARAMS)

		return;



	__setscheduler_params(p, attr);



	/*

	 * Keep a potential priority boosting if called from

	 * sched_setscheduler().

	 */

	p->prio = normal_prio(p);

	if (keep_boost)

		p->prio = rt_effective_prio(p, p->prio);



	if (dl_prio(p->prio))

		p->sched_class = &dl_sched_class;

	else if (rt_prio(p->prio))

		p->sched_class = &rt_sched_class;

	else

		p->sched_class = &fair_sched_class;

}



/*

 * Check the target process has a UID that matches the current process's:

 */
@@ -5376,8 +5398,10 @@ static int __sched_setscheduler(struct task_struct *p, 
				const struct sched_attr *attr,

				bool user, bool pi)

{

	int oldpolicy = -1, policy = attr->sched_policy;

	int retval, oldprio, newprio, queued, running;

	int newprio = dl_policy(attr->sched_policy) ? MAX_DL_PRIO - 1 :

		      MAX_RT_PRIO - 1 - attr->sched_priority;

	int retval, oldprio, oldpolicy = -1, queued, running;

	int new_effective_prio, policy = attr->sched_policy;

	const struct sched_class *prev_class;

	struct rq_flags rf;

	int reset_on_fork;
@@ -5587,7 +5611,6 @@ static int __sched_setscheduler(struct task_struct *p, 
	p->sched_reset_on_fork = reset_on_fork;

	oldprio = p->prio;



	newprio = __normal_prio(policy, attr->sched_priority, attr->sched_nice);

	if (pi) {

		/*

		 * Take priority boosted tasks into account. If the new
@@ -5596,8 +5619,8 @@ static int __sched_setscheduler(struct task_struct *p, 
		 * the runqueue. This will be done when the task deboost

		 * itself.

		 */

		newprio = rt_effective_prio(p, newprio);

		if (newprio == oldprio)

		new_effective_prio = rt_effective_prio(p, newprio);

		if (new_effective_prio == oldprio)

			queue_flags &= ~DEQUEUE_MOVE;

	}
@@ -5610,10 +5633,7 @@ static int __sched_setscheduler(struct task_struct *p, 


	prev_class = p->sched_class;



	if (!(attr->sched_flags & SCHED_FLAG_KEEP_PARAMS)) {

		__setscheduler_params(p, attr);

		__setscheduler_prio(p, newprio);

	}

	__setscheduler(rq, p, attr, pi);

	__setscheduler_uclamp(p, attr);



	if (queued) {