From nobody Sun Feb 8 19:38:24 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5C64BEDEC6A for ; Wed, 13 Sep 2023 14:57:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240794AbjIMNLV (ORCPT ); Wed, 13 Sep 2023 09:11:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35032 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240757AbjIMNLQ (ORCPT ); Wed, 13 Sep 2023 09:11:16 -0400 Received: from galois.linutronix.de (Galois.linutronix.de [IPv6:2a0a:51c0:0:12e:550::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2474C19B4; Wed, 13 Sep 2023 06:11:12 -0700 (PDT) Date: Wed, 13 Sep 2023 13:11:10 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1694610670; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=yiHtROo0mHoU96HoSj5AlQkEnX0RfB1qv0v/OKybK+0=; b=sRXnpgkdvD6jBp68/SmN20twhtV+b6HU9rJLmxV1wiPS6p0JnQhEGSeSuFUejXuAxp+XDQ 1a5QRWS24UYGaaKThWCilXGOBDNz5WGZn3zNwVuVaBYQyR2ItFtrMYvyB/aEropXBlepu/ zoSnoknPtcgwMHuYS2qz8qkA8LgYVJtzzeccP9naCxe5t/yrlMIM2razn3X6jG+6uSueJg qtsDs0yDtD7140JPQJSzP3ENpS2ZbJgQS74jRlVtyDPEy3ONZk61QdEkR6iadFuJoZGR7D qKgMTBdzNWEFWr5yjJSULWD+cSAS2coMkDYLpB9FmjI7bdQtobjL1RzL+0UrUg== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1694610670; h=from:from:sender:sender:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=yiHtROo0mHoU96HoSj5AlQkEnX0RfB1qv0v/OKybK+0=; b=YULRz2amsND1NERB7NPsayN2wAwavIwsUEgGOpaYM4OZ11casOixVn20LIsrklAV2NlWgV xpiyyC3b20P3AZDA== From: "tip-bot2 for Peter Zijlstra" Sender: tip-bot2@linutronix.de Reply-to: linux-kernel@vger.kernel.org To: linux-tip-commits@vger.kernel.org Subject: [tip: sched/core] sched: Misc cleanups Cc: "Peter Zijlstra (Intel)" , Ingo Molnar , x86@kernel.org, linux-kernel@vger.kernel.org MIME-Version: 1.0 Message-ID: <169461067011.27769.11049015770403504197.tip-bot2@tip-bot2> Robot-ID: Robot-Unsubscribe: Contact to get blacklisted from these emails Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The following commit has been merged into the sched/core branch of tip: Commit-ID: 0e34600ac9317dbe5f0a7bfaa3d7187d757572ed Gitweb: https://git.kernel.org/tip/0e34600ac9317dbe5f0a7bfaa3d7187d7= 57572ed Author: Peter Zijlstra AuthorDate: Fri, 09 Jun 2023 20:52:49 +02:00 Committer: Ingo Molnar CommitterDate: Wed, 13 Sep 2023 15:01:48 +02:00 sched: Misc cleanups Random remaining guard use... Signed-off-by: Peter Zijlstra (Intel) Signed-off-by: Ingo Molnar --- kernel/sched/core.c | 167 ++++++++++++++++--------------------------- 1 file changed, 63 insertions(+), 104 deletions(-) diff --git a/kernel/sched/core.c b/kernel/sched/core.c index 5d9f363..76662d8 100644 --- a/kernel/sched/core.c +++ b/kernel/sched/core.c @@ -1480,16 +1480,12 @@ static void __uclamp_update_util_min_rt_default(str= uct task_struct *p) =20 static void uclamp_update_util_min_rt_default(struct task_struct *p) { - struct rq_flags rf; - struct rq *rq; - if (!rt_task(p)) return; =20 /* Protect updates to p->uclamp_* */ - rq =3D task_rq_lock(p, &rf); + guard(task_rq_lock)(p); __uclamp_update_util_min_rt_default(p); - task_rq_unlock(rq, p, &rf); } =20 static inline struct uclamp_se @@ -1785,9 +1781,8 @@ static void uclamp_update_root_tg(void) uclamp_se_set(&tg->uclamp_req[UCLAMP_MAX], sysctl_sched_uclamp_util_max, false); =20 - rcu_read_lock(); + guard(rcu)(); cpu_util_update_eff(&root_task_group.css); - rcu_read_unlock(); } #else static void uclamp_update_root_tg(void) { } @@ -1814,10 +1809,9 @@ static void uclamp_sync_util_min_rt_default(void) smp_mb__after_spinlock(); read_unlock(&tasklist_lock); =20 - rcu_read_lock(); + guard(rcu)(); for_each_process_thread(g, p) uclamp_update_util_min_rt_default(p); - rcu_read_unlock(); } =20 static int sysctl_sched_uclamp_handler(struct ctl_table *table, int write, @@ -2250,20 +2244,13 @@ static __always_inline 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 =3D __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); } =20 /* @@ -2417,10 +2404,9 @@ void migrate_disable(void) return; } =20 - preempt_disable(); + guard(preempt)(); this_rq()->nr_pinned++; p->migration_disabled =3D 1; - preempt_enable(); } EXPORT_SYMBOL_GPL(migrate_disable); =20 @@ -2444,7 +2430,7 @@ void migrate_enable(void) * 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 !=3D &p->cpus_mask) __set_cpus_allowed_ptr(p, &ac); /* @@ -2455,7 +2441,6 @@ void migrate_enable(void) barrier(); p->migration_disabled =3D 0; this_rq()->nr_pinned--; - preempt_enable(); } EXPORT_SYMBOL_GPL(migrate_enable); =20 @@ -3516,13 +3501,11 @@ out: */ void kick_process(struct task_struct *p) { - int cpu; + guard(preempt)(); + int cpu =3D task_cpu(p); =20 - preempt_disable(); - cpu =3D task_cpu(p); if ((cpu !=3D smp_processor_id()) && task_curr(p)) smp_send_reschedule(cpu); - preempt_enable(); } EXPORT_SYMBOL_GPL(kick_process); =20 @@ -6368,8 +6351,9 @@ static void sched_core_balance(struct rq *rq) struct sched_domain *sd; int cpu =3D cpu_of(rq); =20 - preempt_disable(); - rcu_read_lock(); + guard(preempt)(); + guard(rcu)(); + raw_spin_rq_unlock_irq(rq); for_each_domain(cpu, sd) { if (need_resched()) @@ -6379,8 +6363,6 @@ static void sched_core_balance(struct rq *rq) break; } raw_spin_rq_lock_irq(rq); - rcu_read_unlock(); - preempt_enable(); } =20 static DEFINE_PER_CPU(struct balance_callback, core_balance_head); @@ -8258,8 +8240,6 @@ SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sch= ed_attr __user *, uattr, #ifdef CONFIG_SMP int dl_task_check_affinity(struct task_struct *p, const struct cpumask *ma= sk) { - int ret =3D 0; - /* * If the task isn't a deadline task or admission control is * disabled then we don't care about affinity changes. @@ -8273,11 +8253,11 @@ int dl_task_check_affinity(struct task_struct *p, c= onst struct cpumask *mask) * 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 =3D -EBUSY; - rcu_read_unlock(); - return ret; + return -EBUSY; + + return 0; } #endif =20 @@ -10509,11 +10489,9 @@ static int cpu_cgroup_css_online(struct cgroup_sub= sys_state *css) =20 #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 =20 return 0; @@ -10664,8 +10642,8 @@ static ssize_t cpu_uclamp_write(struct kernfs_open_= file *of, char *buf, =20 static_branch_enable(&sched_uclamp_used); =20 - mutex_lock(&uclamp_mutex); - rcu_read_lock(); + guard(mutex)(&uclamp_mutex); + guard(rcu)(); =20 tg =3D css_tg(of_css(of)); if (tg->uclamp_req[clamp_id].value !=3D req.util) @@ -10680,9 +10658,6 @@ static ssize_t cpu_uclamp_write(struct kernfs_open_= file *of, char *buf, /* Update effective clamps to track the most restrictive value */ cpu_util_update_eff(of_css(of)); =20 - rcu_read_unlock(); - mutex_unlock(&uclamp_mutex); - return nbytes; } =20 @@ -10708,10 +10683,10 @@ static inline void cpu_uclamp_print(struct seq_fi= le *sf, u64 percent; u32 rem; =20 - rcu_read_lock(); - tg =3D css_tg(seq_css(sf)); - util_clamp =3D tg->uclamp_req[clamp_id].value; - rcu_read_unlock(); + scoped_guard (rcu) { + tg =3D css_tg(seq_css(sf)); + util_clamp =3D tg->uclamp_req[clamp_id].value; + } =20 if (util_clamp =3D=3D SCHED_CAPACITY_SCALE) { seq_puts(sf, "max\n"); @@ -11033,7 +11008,6 @@ static int tg_cfs_schedulable_down(struct task_grou= p *tg, void *data) =20 static int __cfs_schedulable(struct task_group *tg, u64 period, u64 quota) { - int ret; struct cfs_schedulable_data data =3D { .tg =3D tg, .period =3D period, @@ -11045,11 +11019,8 @@ static int __cfs_schedulable(struct task_group *tg= , u64 period, u64 quota) do_div(data.quota, NSEC_PER_USEC); } =20 - rcu_read_lock(); - ret =3D 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); } =20 static int cpu_cfs_stat_show(struct seq_file *sf, void *v) @@ -11654,14 +11625,12 @@ int __sched_mm_cid_migrate_from_fetch_cid(struct = rq *src_rq, * 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 =3D rcu_dereference(src_rq->curr); if (READ_ONCE(src_task->mm_cid_active) && src_task->mm =3D=3D mm) { - rcu_read_unlock(); t->last_mm_cid =3D -1; return -1; } - rcu_read_unlock(); =20 return src_cid; } @@ -11705,18 +11674,17 @@ int __sched_mm_cid_migrate_from_try_steal_cid(str= uct rq *src_rq, * the lazy-put flag, this task will be responsible for transitioning * from lazy-put flag set to MM_CID_UNSET. */ - rcu_read_lock(); - src_task =3D rcu_dereference(src_rq->curr); - if (READ_ONCE(src_task->mm_cid_active) && src_task->mm =3D=3D 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 =3D -1; - return -1; + scoped_guard (rcu) { + src_task =3D rcu_dereference(src_rq->curr); + if (READ_ONCE(src_task->mm_cid_active) && src_task->mm =3D=3D mm) { + /* + * 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 =3D -1; + return -1; + } } - rcu_read_unlock(); =20 /* * The src_cid is unused, so it can be unset. @@ -11789,7 +11757,6 @@ static void sched_mm_cid_remote_clear(struct mm_str= uct *mm, struct mm_cid *pcpu_ { struct rq *rq =3D cpu_rq(cpu); struct task_struct *t; - unsigned long flags; int cid, lazy_cid; =20 cid =3D READ_ONCE(pcpu_cid->cid); @@ -11824,23 +11791,21 @@ static void sched_mm_cid_remote_clear(struct mm_s= truct *mm, struct mm_cid *pcpu_ * the lazy-put flag, that task will be responsible for transitioning * from lazy-put flag set to MM_CID_UNSET. */ - rcu_read_lock(); - t =3D rcu_dereference(rq->curr); - if (READ_ONCE(t->mm_cid_active) && t->mm =3D=3D mm) { - rcu_read_unlock(); - return; + scoped_guard (rcu) { + t =3D rcu_dereference(rq->curr); + if (READ_ONCE(t->mm_cid_active) && t->mm =3D=3D mm) + return; } - rcu_read_unlock(); =20 /* * 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); - if (try_cmpxchg(&pcpu_cid->cid, &lazy_cid, MM_CID_UNSET)) - __mm_cid_put(mm, cid); - local_irq_restore(flags); + scoped_guard (irqsave) { + if (try_cmpxchg(&pcpu_cid->cid, &lazy_cid, MM_CID_UNSET)) + __mm_cid_put(mm, cid); + } } =20 static void sched_mm_cid_remote_clear_old(struct mm_struct *mm, int cpu) @@ -11862,14 +11827,13 @@ 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(); - curr =3D rcu_dereference(rq->curr); - if (READ_ONCE(curr->mm_cid_active) && curr->mm =3D=3D mm) { - WRITE_ONCE(pcpu_cid->time, rq_clock); - rcu_read_unlock(); - return; + scoped_guard (rcu) { + curr =3D rcu_dereference(rq->curr); + if (READ_ONCE(curr->mm_cid_active) && curr->mm =3D=3D mm) { + WRITE_ONCE(pcpu_cid->time, rq_clock); + return; + } } - rcu_read_unlock(); =20 if (rq_clock < pcpu_cid->time + SCHED_MM_CID_PERIOD_NS) return; @@ -11963,7 +11927,6 @@ void task_tick_mm_cid(struct rq *rq, struct task_st= ruct *curr) void sched_mm_cid_exit_signals(struct task_struct *t) { struct mm_struct *mm =3D t->mm; - struct rq_flags rf; struct rq *rq; =20 if (!mm) @@ -11971,7 +11934,7 @@ void sched_mm_cid_exit_signals(struct task_struct *= t) =20 preempt_disable(); rq =3D 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); /* @@ -11981,13 +11944,11 @@ void sched_mm_cid_exit_signals(struct task_struct= *t) smp_mb(); mm_cid_put(mm); t->last_mm_cid =3D t->mm_cid =3D -1; - rq_unlock_irqrestore(rq, &rf); } =20 void sched_mm_cid_before_execve(struct task_struct *t) { struct mm_struct *mm =3D t->mm; - struct rq_flags rf; struct rq *rq; =20 if (!mm) @@ -11995,7 +11956,7 @@ void sched_mm_cid_before_execve(struct task_struct = *t) =20 preempt_disable(); rq =3D 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); /* @@ -12005,13 +11966,11 @@ void sched_mm_cid_before_execve(struct task_struc= t *t) smp_mb(); mm_cid_put(mm); t->last_mm_cid =3D t->mm_cid =3D -1; - rq_unlock_irqrestore(rq, &rf); } =20 void sched_mm_cid_after_execve(struct task_struct *t) { struct mm_struct *mm =3D t->mm; - struct rq_flags rf; struct rq *rq; =20 if (!mm) @@ -12019,16 +11978,16 @@ void sched_mm_cid_after_execve(struct task_struct= *t) =20 preempt_disable(); rq =3D this_rq(); - rq_lock_irqsave(rq, &rf); - preempt_enable_no_resched(); /* holding spinlock */ - WRITE_ONCE(t->mm_cid_active, 1); - /* - * Store t->mm_cid_active before loading per-mm/cpu cid. - * Matches barrier in sched_mm_cid_remote_clear_old(). - */ - smp_mb(); - t->last_mm_cid =3D t->mm_cid =3D mm_cid_get(rq, mm); - rq_unlock_irqrestore(rq, &rf); + scoped_guard (rq_lock_irqsave, rq) { + preempt_enable_no_resched(); /* holding spinlock */ + WRITE_ONCE(t->mm_cid_active, 1); + /* + * Store t->mm_cid_active before loading per-mm/cpu cid. + * Matches barrier in sched_mm_cid_remote_clear_old(). + */ + smp_mb(); + t->last_mm_cid =3D t->mm_cid =3D mm_cid_get(rq, mm); + } rseq_set_notify_resume(t); }