FAILED: patch "[PATCH] sched_ext: Take cgroup_lock() first in scx_cgroup_lock()" failed to apply to 6.18-stable tree
Subsystems (3)
[email protected]
maintainerThe patch below does not apply to the 6.18-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-6.18.y
git checkout FETCH_HEAD
git cherry-pick -x 5f8b69642d18e1f3e11996707842ac530444e959
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026081715-muscular-drizzly-bfad@gregkh' --subject-prefix 'PATCH 6.18.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 5f8b69642d18e1f3e11996707842ac530444e959 Mon Sep 17 00:00:00 2001
From: Tejun Heo <[email protected]>
Date: Thu, 16 Jul 2026 10:44:02 -1000
Subject: [PATCH] sched_ext: Take cgroup_lock() first in scx_cgroup_lock()
scx_cgroup_lock() write-locks scx_cgroup_ops_rwsem and then takes cgroup_lock(), which can deadlock through kernfs:
scx enable/disable cgroup rmdir cpu.weight write ------------------ ------------ ----------------
cgroup_lock()
percpu_down_write(rwsem)
cgroup_lock()
kernfs_get_active() percpu_down_read(rwsem)
kernfs_drain()
The enable path waits for the rmdir to release cgroup_mutex. The rmdir, deactivating the cpu controller's files, waits in kernfs_drain() for the write's active reference. The write, in scx_group_set_weight(), waits for the rwsem behind the pending writer.
Take cgroup_lock() first. The set_* paths take no cgroup locks inside the read side, so a pending write-lock then only waits for read sections that always run to completion, and no dependency from the rwsem back to cgroup_mutex remains.
kernel/sched/ext/ext.c +7 -2
@@ -4580,20 +4580,25 @@ static struct cgroup *root_cgroup(void) return &cgrp_dfl_root.cgrp; } +/* +* cgroup_lock() must nest outside the rwsem write side: a writer waiting +* for cgroup_mutex deadlocks with cgroup teardown, which holds it while +* draining a set_* file write blocked on the rwsem behind the writer. +*/ static void scx_cgroup_lock (void ) { +cgroup_lock ();#ifdef CONFIG_EXT_GROUP_SCHED percpu_down_write (&scx_cgroup_ops_rwsem);#endif -cgroup_lock (); }static void scx_cgroup_unlock (void ) { -cgroup_unlock ();#ifdef CONFIG_EXT_GROUP_SCHED percpu_up_write (&scx_cgroup_ops_rwsem);#endif +cgroup_unlock (); }#else /* CONFIG_EXT_GROUP_SCHED || CONFIG_EXT_SUB_SCHED */ static inline struct cgroup *root_cgroup (void ) {return NULL ; }
Sasha Levin
maintainerPATCH 1/3 sched_ext: Update p->scx.disallow warning in scx_init_task()
From: Tejun Heo <[email protected]>
[ Upstream commit 0454a604b98a9bf301e82860cd216ec4ac563668 ]
- Always trigger the warning if p->scx.disallow is set for fork inits. There is no reason to set it during forks.
- Flip the positions of if/else arms to ease adding error conditions.
Stable-dep-of: 5f8b69642d18 ("sched_ext: Take cgroup_lock() first in scx_cgroup_lock()")
--- kernel/sched/ext.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
kernel/sched/ext.c +4 -4
@@ -2841,7 +2841,10 @@ static int scx_init_task(struct task_struct *p, struct task_group *tg, bool forkscx_set_task_state (p,SCX_TASK_INIT );if (p->scx.disallow) { -if (!fork) { +if (unlikely (fork)) { +scx_error (sch,"ops.init_task() set task->scx.disallow for %s[%d] during fork" , + p->comm, p->pid); + }else {struct rq *rq;struct rq_flags rf;
@@ -2860,9 +2863,6 @@ static int scx_init_task(struct task_struct *p, struct task_group *tg, bool fork }task_rq_unlock (rq, p, &rf); - }else if (p->policy ==SCHED_EXT ) { -scx_error (sch,"ops.init_task() set task->scx.disallow for %s[%d] during fork" , - p->comm, p->pid); } }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/3 sched_ext: Reorganize enable/disable path for multi-scheduler support
From: Tejun Heo <[email protected]>
[ Upstream commit dbd542a8fac7bcfba91e353f2a522e1bf2fbee27 ]
In preparation for multiple scheduler support, reorganize the enable and disable paths to make scheduler instances explicit. Extract scx_root_disable() from scx_disable_workfn(). Rename scx_enable_workfn() to scx_root_enable_workfn(). Change scx_disable() to take @sch parameter and only queue disable_work if scx_claim_exit() succeeds for consistency. Move exit_kind validation into scx_claim_exit(). The sysrq handler now prints a message when no scheduler is loaded.
These changes don't materially affect user-visible behavior.
v2: Keep scx_enable() name as-is and only rename the workfn to
scx_root_enable_workfn(). Change scx_enable() return type to s32.
Stable-dep-of: 5f8b69642d18 ("sched_ext: Take cgroup_lock() first in scx_cgroup_lock()")
--- kernel/sched/ext.c | 78 +++++++++++++++++++++++++--------------------- 1 file changed, 43 insertions(+), 35 deletions(-)
kernel/sched/ext.c +43 -35
@@ -3029,8 +3029,8 @@ void sched_ext_free(struct task_struct *p)raw_spin_unlock_irqrestore (&scx_tasks_lock, flags);/* -* @p is off scx_tasks and wholly ours. scx_enable()'s READY -> ENABLED -* transitions can't race us. Disable ops for @p. +* @p is off scx_tasks and wholly ours. scx_root_enable()'s READY -> +* ENABLED transitions can't race us. Disable ops for @p. */ if (scx_get_task_state (p) !=SCX_TASK_NONE ) {struct rq_flags rf;
@@ -3962,24 +3962,12 @@ static void free_kick_pseqs(void) } } -static void scx_disable_workfn (struct kthread_work *work) +static void scx_root_disable (struct scx_sched *sch) { - struct scx_sched *sch = container_of(work, struct scx_sched, disable_work);struct scx_exit_info *ei = sch->exit_info;struct scx_task_iter sti;struct task_struct *p; -int kind, cpu; - - kind =atomic_read (&sch->exit_kind); -while (true) { -if (kind ==SCX_EXIT_DONE )/* already disabled? */ -return ; -WARN_ON_ONCE (kind ==SCX_EXIT_NONE ); -if (atomic_try_cmpxchg (&sch->exit_kind, &kind,SCX_EXIT_DONE )) -break ; - } - ei->kind = kind; - ei->reason =scx_exit_reason (ei->kind); +int cpu;/* guarantee forward progress by bypassing scx_ops */ scx_bypass (true);
@@ -4124,6 +4112,9 @@ static bool scx_claim_exit(struct scx_sched *sch, enum scx_exit_kind kind)lockdep_assert_preemption_disabled (); +if (WARN_ON_ONCE (kind ==SCX_EXIT_NONE || kind ==SCX_EXIT_DONE )) + kind =SCX_EXIT_ERROR ; +if (!atomic_try_cmpxchg (&sch->exit_kind, &none, kind))return false;
@@ -4136,21 +4127,31 @@ static bool scx_claim_exit(struct scx_sched *sch, enum scx_exit_kind kind)return true; } -static void scx_disable (enum scx_exit_kind kind) +static void scx_disable_workfn (struct kthread_work *work) { -struct scx_sched *sch; + struct scx_sched *sch = container_of(work, struct scx_sched, disable_work); +struct scx_exit_info *ei = sch->exit_info; +int kind; -if (WARN_ON_ONCE (kind ==SCX_EXIT_NONE || kind ==SCX_EXIT_DONE )) - kind =SCX_EXIT_ERROR ; + kind =atomic_read (&sch->exit_kind); +while (true) { +if (kind ==SCX_EXIT_DONE )/* already disabled? */ +return ; +WARN_ON_ONCE (kind ==SCX_EXIT_NONE ); +if (atomic_try_cmpxchg (&sch->exit_kind, &kind,SCX_EXIT_DONE )) +break ; + } + ei->kind = kind; + ei->reason =scx_exit_reason (ei->kind); -rcu_read_lock (); - sch =rcu_dereference (scx_root); -if (sch) { -guard (preempt)(); -scx_claim_exit (sch, kind); +scx_root_disable (sch); +} + +static void scx_disable (struct scx_sched *sch,enum scx_exit_kind kind) +{ +guard (preempt)(); +if (scx_claim_exit (sch, kind))kthread_queue_work (sch->helper, &sch->disable_work); - } -rcu_read_unlock (); }static void dump_newline (struct seq_buf *s)
@@ -4662,10 +4663,9 @@ struct scx_enable_cmd {int ret; }; -static void scx_enable_workfn (struct kthread_work *work) +static void scx_root_enable_workfn (struct kthread_work *work) { -struct scx_enable_cmd *cmd = - container_of(work, struct scx_enable_cmd, work); + struct scx_enable_cmd *cmd = container_of(work, struct scx_enable_cmd, work);struct sched_ext_ops *ops = cmd->ops;struct scx_sched *sch;struct scx_task_iter sti;
@@ -4915,12 +4915,12 @@ static void scx_enable_workfn(struct kthread_work *work)* Flush scx_disable_work to ensure that error is reported before init * completion. sch's base reference will be put by bpf_scx_unreg(). */ -scx_error (sch,"scx_enable() failed (%d)" , ret); +scx_error (sch,"scx_root_enable() failed (%d)" , ret);kthread_flush_work (&sch->disable_work); cmd->ret =0 ; } -static int scx_enable (struct sched_ext_ops *ops,struct bpf_link *link) +static s32 scx_enable (struct sched_ext_ops *ops,struct bpf_link *link) {static struct kthread_worker *helper;static DEFINE_MUTEX (helper_mutex);
@@ -4946,7 +4946,7 @@ static int scx_enable(struct sched_ext_ops *ops, struct bpf_link *link)mutex_unlock (&helper_mutex); } -kthread_init_work (&cmd.work, scx_enable_workfn); +kthread_init_work (&cmd.work, scx_root_enable_workfn); cmd.ops = ops;kthread_queue_work (READ_ONCE (helper), &cmd.work);
@@ -5089,7 +5089,7 @@ static void bpf_scx_unreg(void *kdata, struct bpf_link *link)struct sched_ext_ops *ops = kdata;struct scx_sched *sch = ops->priv; -scx_disable (SCX_EXIT_UNREG ); +scx_disable (sch,SCX_EXIT_UNREG );kthread_flush_work (&sch->disable_work);kobject_put (&sch->kobj); }
@@ -5217,7 +5217,15 @@ static struct bpf_struct_ops bpf_sched_ext_ops = {static void sysrq_handle_sched_ext_reset (u8 key) { -scx_disable (SCX_EXIT_SYSRQ ); +struct scx_sched *sch; + +rcu_read_lock (); + sch =rcu_dereference (scx_root); +if (likely (sch)) +scx_disable (sch,SCX_EXIT_SYSRQ ); +else +pr_info ("sched_ext: BPF schedulers not loaded\n" ); +rcu_read_unlock (); }static const struct sysrq_key_op sysrq_sched_ext_reset_op = {
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/3 sched_ext: Take cgroup_lock() first in scx_cgroup_lock()
In reply to Sasha LevinFrom: Tejun Heo <[email protected]>
[ Upstream commit 5f8b69642d18e1f3e11996707842ac530444e959 ]
scx_cgroup_lock() write-locks scx_cgroup_ops_rwsem and then takes cgroup_lock(), which can deadlock through kernfs:
scx enable/disable cgroup rmdir cpu.weight write ------------------ ------------ ----------------
cgroup_lock()
percpu_down_write(rwsem)
cgroup_lock()
kernfs_get_active() percpu_down_read(rwsem)
kernfs_drain()
The enable path waits for the rmdir to release cgroup_mutex. The rmdir, deactivating the cpu controller's files, waits in kernfs_drain() for the write's active reference. The write, in scx_group_set_weight(), waits for the rwsem behind the pending writer.
Take cgroup_lock() first. The set_* paths take no cgroup locks inside the read side, so a pending write-lock then only waits for read sections that always run to completion, and no dependency from the rwsem back to cgroup_mutex remains.
--- kernel/sched/ext.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
kernel/sched/ext.c +7 -2
@@ -3313,16 +3313,21 @@ void scx_group_set_bandwidth(struct task_group *tg, percpu_up_read(&scx_cgroup_ops_rwsem); } +/* +* cgroup_lock() must nest outside the rwsem write side: a writer waiting +* for cgroup_mutex deadlocks with cgroup teardown, which holds it while +* draining a set_* file write blocked on the rwsem behind the writer. +*/ static void scx_cgroup_lock (void ) { -percpu_down_write (&scx_cgroup_ops_rwsem);cgroup_lock (); +percpu_down_write (&scx_cgroup_ops_rwsem); }static void scx_cgroup_unlock (void ) { -cgroup_unlock ();percpu_up_write (&scx_cgroup_ops_rwsem); +cgroup_unlock (); }#else /* CONFIG_EXT_GROUP_SCHED */
Signature · 1 line
2.53.0