sched: Misc cleanups

static void uclamp_update_util_min_rt_default(struct task_struct *p)

{

	struct rq_flags rf;

	struct rq *rq;

	if (!rt_task(p))

		return;

	/* Protect updates to p->uclamp_* */

	rq = task_rq_lock(p, &rf);

	guard(task_rq_lock)(p);

	__uclamp_update_util_min_rt_default(p);

	task_rq_unlock(rq, p, &rf);

}

static inline struct uclamp_se

	uclamp_se_set(&tg->uclamp_req[UCLAMP_MAX],

		      sysctl_sched_uclamp_util_max, false);

	rcu_read_lock();

	guard(rcu)();

	cpu_util_update_eff(&root_task_group.css);

	rcu_read_unlock();

}

#else

static void uclamp_update_root_tg(void) { }

	smp_mb__after_spinlock();

	read_unlock(&tasklist_lock);

	rcu_read_lock();

	guard(rcu)();

	for_each_process_thread(g, p)

		uclamp_update_util_min_rt_default(p);

	rcu_read_unlock();

}

static int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,

int task_state_match(struct task_struct *p, unsigned int state)

{

#ifdef CONFIG_PREEMPT_RT

	int match;

	/*

	 * Serialize against current_save_and_set_rtlock_wait_state() and

	 * current_restore_rtlock_saved_state().

	 */

	raw_spin_lock_irq(&p->pi_lock);

	match = __task_state_match(p, state);

	raw_spin_unlock_irq(&p->pi_lock);

	return match;

#else

	return __task_state_match(p, state);

	guard(raw_spinlock_irq)(&p->pi_lock);

#endif

	return __task_state_match(p, state);

}

/*

		return;

	}

	preempt_disable();

	guard(preempt)();

	this_rq()->nr_pinned++;

	p->migration_disabled = 1;

	preempt_enable();

}

EXPORT_SYMBOL_GPL(migrate_disable);

	 * Ensure stop_task runs either before or after this, and that

	 * __set_cpus_allowed_ptr(SCA_MIGRATE_ENABLE) doesn't schedule().

	 */

	preempt_disable();

	guard(preempt)();

	if (p->cpus_ptr != &p->cpus_mask)

		__set_cpus_allowed_ptr(p, &ac);

	/*

	barrier();

	p->migration_disabled = 0;

	this_rq()->nr_pinned--;

	preempt_enable();

}

EXPORT_SYMBOL_GPL(migrate_enable);

 */

void kick_process(struct task_struct *p)

{

	int cpu;

	guard(preempt)();

	int cpu = task_cpu(p);

	preempt_disable();

	cpu = task_cpu(p);

	if ((cpu != smp_processor_id()) && task_curr(p))

		smp_send_reschedule(cpu);

	preempt_enable();

}

EXPORT_SYMBOL_GPL(kick_process);

	struct sched_domain *sd;

	int cpu = cpu_of(rq);

	preempt_disable();

	rcu_read_lock();

	guard(preempt)();

	guard(rcu)();

	raw_spin_rq_unlock_irq(rq);

	for_each_domain(cpu, sd) {

		if (need_resched())

			break;

	}

	raw_spin_rq_lock_irq(rq);

	rcu_read_unlock();

	preempt_enable();

}

static DEFINE_PER_CPU(struct balance_callback, core_balance_head);

#ifdef CONFIG_SMP

int dl_task_check_affinity(struct task_struct *p, const struct cpumask *mask)

{

	int ret = 0;

	/*

	 * If the task isn't a deadline task or admission control is

	 * disabled then we don't care about affinity changes.

	 * tasks allowed to run on all the CPUs in the task's

	 * root_domain.

	 */

	rcu_read_lock();

	guard(rcu)();

	if (!cpumask_subset(task_rq(p)->rd->span, mask))

		ret = -EBUSY;

	rcu_read_unlock();

	return ret;

		return -EBUSY;

	return 0;

}

#endif

#ifdef CONFIG_UCLAMP_TASK_GROUP

	/* Propagate the effective uclamp value for the new group */

	mutex_lock(&uclamp_mutex);

	rcu_read_lock();

	guard(mutex)(&uclamp_mutex);

	guard(rcu)();

	cpu_util_update_eff(css);

	rcu_read_unlock();

	mutex_unlock(&uclamp_mutex);

#endif

	return 0;

	static_branch_enable(&sched_uclamp_used);

	mutex_lock(&uclamp_mutex);

	rcu_read_lock();

	guard(mutex)(&uclamp_mutex);

	guard(rcu)();

	tg = css_tg(of_css(of));

	if (tg->uclamp_req[clamp_id].value != req.util)

	/* Update effective clamps to track the most restrictive value */

	cpu_util_update_eff(of_css(of));

	rcu_read_unlock();

	mutex_unlock(&uclamp_mutex);

	return nbytes;

}

	u64 percent;

	u32 rem;

	rcu_read_lock();

	scoped_guard (rcu) {

		tg = css_tg(seq_css(sf));

		util_clamp = tg->uclamp_req[clamp_id].value;

	rcu_read_unlock();

	}

	if (util_clamp == SCHED_CAPACITY_SCALE) {

		seq_puts(sf, "max\n");

static int __cfs_schedulable(struct task_group *tg, u64 period, u64 quota)

{

	int ret;

	struct cfs_schedulable_data data = {

		.tg = tg,

		.period = period,

		do_div(data.quota, NSEC_PER_USEC);

	}

	rcu_read_lock();

	ret = walk_tg_tree(tg_cfs_schedulable_down, tg_nop, &data);

	rcu_read_unlock();

	return ret;

	guard(rcu)();

	return walk_tg_tree(tg_cfs_schedulable_down, tg_nop, &data);

}

static int cpu_cfs_stat_show(struct seq_file *sf, void *v)

	 * are not the last task to be migrated from this cpu for this mm, so

	 * there is no need to move src_cid to the destination cpu.

	 */

	rcu_read_lock();

	guard(rcu)();

	src_task = rcu_dereference(src_rq->curr);

	if (READ_ONCE(src_task->mm_cid_active) && src_task->mm == mm) {

		rcu_read_unlock();

		t->last_mm_cid = -1;

		return -1;

	}

	rcu_read_unlock();

	return src_cid;

}

	 * the lazy-put flag, this task will be responsible for transitioning

	 * from lazy-put flag set to MM_CID_UNSET.

	 */

	rcu_read_lock();

	scoped_guard (rcu) {

		src_task = rcu_dereference(src_rq->curr);

		if (READ_ONCE(src_task->mm_cid_active) && src_task->mm == mm) {

		rcu_read_unlock();

			/*

			 * We observed an active task for this mm, there is therefore

			 * no point in moving this cid to the destination cpu.

			t->last_mm_cid = -1;

			return -1;

		}

	rcu_read_unlock();

	}

	/*

	 * The src_cid is unused, so it can be unset.

{

	struct rq *rq = cpu_rq(cpu);

	struct task_struct *t;

	unsigned long flags;

	int cid, lazy_cid;

	cid = READ_ONCE(pcpu_cid->cid);

	 * the lazy-put flag, that task will be responsible for transitioning

	 * from lazy-put flag set to MM_CID_UNSET.

	 */

	rcu_read_lock();

	scoped_guard (rcu) {

		t = rcu_dereference(rq->curr);

	if (READ_ONCE(t->mm_cid_active) && t->mm == mm) {

		rcu_read_unlock();

		if (READ_ONCE(t->mm_cid_active) && t->mm == mm)

			return;

	}

	rcu_read_unlock();

	/*

	 * The cid is unused, so it can be unset.

	 * Disable interrupts to keep the window of cid ownership without rq

	 * lock small.

	 */

	local_irq_save(flags);

	scoped_guard (irqsave) {

		if (try_cmpxchg(&pcpu_cid->cid, &lazy_cid, MM_CID_UNSET))

			__mm_cid_put(mm, cid);

	local_irq_restore(flags);

	}

}

static void sched_mm_cid_remote_clear_old(struct mm_struct *mm, int cpu)

	 * snapshot associated with this cid if an active task using the mm is

	 * observed on this rq.

	 */

	rcu_read_lock();

	scoped_guard (rcu) {

		curr = rcu_dereference(rq->curr);

		if (READ_ONCE(curr->mm_cid_active) && curr->mm == mm) {

			WRITE_ONCE(pcpu_cid->time, rq_clock);

		rcu_read_unlock();

			return;

		}

	rcu_read_unlock();

	}

	if (rq_clock < pcpu_cid->time + SCHED_MM_CID_PERIOD_NS)

		return;

void sched_mm_cid_exit_signals(struct task_struct *t)

{

	struct mm_struct *mm = t->mm;

	struct rq_flags rf;

	struct rq *rq;

	if (!mm)

	preempt_disable();

	rq = this_rq();

	rq_lock_irqsave(rq, &rf);

	guard(rq_lock_irqsave)(rq);

	preempt_enable_no_resched();	/* holding spinlock */

	WRITE_ONCE(t->mm_cid_active, 0);

	/*

	smp_mb();

	mm_cid_put(mm);

	t->last_mm_cid = t->mm_cid = -1;

	rq_unlock_irqrestore(rq, &rf);

}

void sched_mm_cid_before_execve(struct task_struct *t)

{

	struct mm_struct *mm = t->mm;

	struct rq_flags rf;

	struct rq *rq;

	if (!mm)

	preempt_disable();

	rq = this_rq();

	rq_lock_irqsave(rq, &rf);

	guard(rq_lock_irqsave)(rq);

	preempt_enable_no_resched();	/* holding spinlock */

	WRITE_ONCE(t->mm_cid_active, 0);

	/*

	smp_mb();

	mm_cid_put(mm);

	t->last_mm_cid = t->mm_cid = -1;

	rq_unlock_irqrestore(rq, &rf);

}

void sched_mm_cid_after_execve(struct task_struct *t)

{

	struct mm_struct *mm = t->mm;

	struct rq_flags rf;

	struct rq *rq;

	if (!mm)

	preempt_disable();

	rq = this_rq();

	rq_lock_irqsave(rq, &rf);

	scoped_guard (rq_lock_irqsave, rq) {

		preempt_enable_no_resched();	/* holding spinlock */

		WRITE_ONCE(t->mm_cid_active, 1);

		/*

		 */

		smp_mb();

		t->last_mm_cid = t->mm_cid = mm_cid_get(rq, mm);

	rq_unlock_irqrestore(rq, &rf);

	}

	rseq_set_notify_resume(t);

}