sched/psi: fix race in pressure_write (CVE-2026-52991)
Subsystems (2)
cover sched/psi: fix race in pressure_write (CVE-2026-52991)
Backport of the CVE-2026-52991 fix.
1/2 (94a4acfec146) clear of->priv on release, turning the UAF into an
easier-to-detect NULL deref.
2/2 (a5b98009f16d, the CVE fix) extend cgroup_mutex to cover all
of->priv accesses, read ctx after taking the kn lock, and NULL-check
of->priv. It depends on 1/2 as discussed in [0].[0] https://lore.kernel.org/all/[email protected]/
Chen Ridong (1):
cgroup/psi: Set of->priv to NULL upon file release
Edward Adam Davis (1):
sched/psi: fix race between file release and pressure write
kernel/cgroup/cgroup.c | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-)
--
2.47.3
PATCH 1/2 cgroup/psi: Set of->priv to NULL upon file release
From: Chen Ridong <[email protected]>
commit 94a4acfec14615e971eb2c9e1fa6c992c85ff6c6 upstream.
Setting of->priv to NULL when the file is released enables earlier bug detection. This allows potential bugs to manifest as NULL pointer dereferences rather than use-after-free errors[1], which are generally more difficult to diagnose.
[1] https://lore.kernel.org/cgroups/[email protected]/T/#m8a3b3f88f0ff3da5925d342e90043394f8b2091b
--- kernel/cgroup/cgroup.c | 1 + 1 file changed, 1 insertion(+)
kernel/cgroup/cgroup.c +1 -0
@@ -4162,6 +4162,7 @@ static void cgroup_file_release(struct kernfs_open_file *of) cft->release (of);put_cgroup_ns (ctx->ns);kfree (ctx); + of->priv =NULL ; } static ssize_t cgroup_file_write(struct kernfs_open_file *of, char *buf,
Signature · 1 line
2.47.3
PATCH 2/2 sched/psi: fix race between file release and pressure write
In reply to Philo LuFrom: Edward Adam Davis <[email protected]>
commit a5b98009f16d8a5fb4a8ff9a193f5735515c38fa upstream.
A potential race condition exists between pressure write and cgroup file release regarding the priv member of struct kernfs_open_file, which triggers the uaf reported in [1].
Consider the following scenario involving execution on two separate CPUs:
CPU0 CPU1
==== ====
vfs_rmdir() kernfs_iop_rmdir() cgroup_rmdir() cgroup_kn_lock_live() cgroup_destroy_locked() cgroup_addrm_files() cgroup_rm_file() kernfs_remove_by_name() kernfs_remove_by_name_ns() vfs_write() __kernfs_remove() new_sync_write() kernfs_drain() kernfs_fop_write_iter() kernfs_drain_open_files() cgroup_file_write() kernfs_release_file() pressure_write() cgroup_file_release() ctx = of->priv; kfree(ctx);
of->priv = NULL; cgroup_kn_unlock()
cgroup_kn_lock_live()
cgroup_get(cgrp)
cgroup_kn_unlock()
if (ctx->psi.trigger) // here, trigger uaf for ctx, that is of->priv
The cgroup_rmdir() is protected by the cgroup_mutex, it also safeguards the memory deallocation of of->priv performed within cgroup_file_release(). However, the operations involving of->priv executed within pressure_write() are not entirely covered by the protection of cgroup_mutex. Consequently, if the code in pressure_write(), specifically the section handling the ctx variable executes after cgroup_file_release() has completed, a uaf vulnerability involving of->priv is triggered.
Therefore, the issue can be resolved by extending the scope of the cgroup_mutex lock within pressure_write() to encompass all code paths involving of->priv, thereby properly synchronizing the race condition occurring between cgroup_file_release() and pressure_write().
And, if an live kn lock can be successfully acquired while executing the pressure write operation, it indicates that the cgroup deletion process has not yet reached its final stage; consequently, the priv pointer within open_file cannot be NULL. Therefore, the operation to retrieve the ctx value must be moved to a point *after* the live kn lock has been successfully acquired.
In another situation, specifically after entering cgroup_kn_lock_live() but before acquiring cgroup_mutex, there exists a different class of race condition:
CPU0: write memory.pressure CPU1: write cgroup.pressure=0
=========================== =============================
kernfs_fop_write_iter()
kernfs_get_active_of(of)
pressure_write()
cgroup_kn_lock_live(memory.pressure)
cgroup_tryget(cgrp)
kernfs_break_active_protection(kn)
... blocks on cgroup_mutex
cgroup_pressure_write() cgroup_kn_lock_live(cgroup.pressure) cgroup_file_show(memory.pressure, false)
kernfs_show(false)
kernfs_drain_open_files()
cgroup_file_release(of)
kfree(ctx)
of->priv = NULL
cgroup_kn_unlock()
... acquires cgroup_mutex
ctx = of->priv; // may now be NULL
if (ctx->psi.trigger) // NULL dereference
Consequently, there is a possibility that of->priv is NULL, the pressure write needs to check for this.
Now that the scope of the cgroup_mutex has been expanded, the original explicit cgroup_get/put operations are no longer necessary, this is because acquiring/releasing the live kn lock inherently executes a cgroup get/put operation.
[1]
BUG: KASAN: slab-use-after-free in pressure_write+0xa4/0x210 kernel/cgroup/cgroup.c:4011 Call Trace: pressure_write+0xa4/0x210 kernel/cgroup/cgroup.c:4011 cgroup_file_write+0x36f/0x790 kernel/cgroup/cgroup.c:4311 kernfs_fop_write_iter+0x3b0/0x540 fs/kernfs/file.c:352 Allocated by task 9352: cgroup_file_open+0x90/0x3a0 kernel/cgroup/cgroup.c:4256 kernfs_fop_open+0x9eb/0xcb0 fs/kernfs/file.c:724 do_dentry_open+0x83d/0x13e0 fs/open.c:949 Freed by task 9353: cgroup_file_release+0xd6/0x100 kernel/cgroup/cgroup.c:4283 kernfs_release_file fs/kernfs/file.c:764 [inline] kernfs_drain_open_files+0x392/0x720 fs/kernfs/file.c:834 kernfs_drain+0x470/0x600 fs/kernfs/dir.c:525
--- kernel/cgroup/cgroup.c | 24 ++++++++++++++++-------- 1 file changed, 16 insertions(+), 8 deletions(-)
kernel/cgroup/cgroup.c +16 -8
@@ -3876,33 +3876,41 @@ static int cgroup_cpu_pressure_show(struct seq_file *seq, void *v)static ssize_t pressure_write (struct kernfs_open_file *of,char *buf,size_t nbytes,enum psi_res res) { -struct cgroup_file_ctx *ctx = of->priv; +struct cgroup_file_ctx *ctx;struct psi_trigger *new;struct cgroup *cgrp;struct psi_group *psi; +ssize_t ret =0 ; cgrp =cgroup_kn_lock_live (of->kn, false);if (!cgrp)return -ENODEV ; -cgroup_get (cgrp); -cgroup_kn_unlock (of->kn); + ctx = of->priv; +if (!ctx) { + ret = -ENODEV ; + goto out_unlock; + }/* Allow only one trigger per file descriptor */ if (ctx->psi.trigger) { -cgroup_put (cgrp); -return -EBUSY ; + ret = -EBUSY ; + goto out_unlock; } psi =cgroup_psi (cgrp); new =psi_trigger_create (psi, buf, res, of->file, of);if (IS_ERR (new)) { -cgroup_put (cgrp); -return PTR_ERR (new); + ret =PTR_ERR (new); + goto out_unlock; }smp_store_release (&ctx->psi.trigger, new); -cgroup_put (cgrp); + +out_unlock: +cgroup_kn_unlock (of->kn); +if (ret) +return ret;return nbytes; }
Signature · 1 line
2.47.3
Sasha Levin
maintainerQuoted 7 lines · Philo Lu
Backport of the CVE-2026-52991 fix.
1/2 (
94a4acfec146) clearof->privon release, turning the UAF into an
easier-to-detect NULL deref.
2/2 (a5b98009f16d, the CVE fix) extendcgroup_mutexto cover allof->priv accesses, read ctx after taking the kn lock, and NULL-check of->priv. It depends on 1/2 as discussed in [0].
I'm holding off on this series (and the 6.6.y/6.1.y ones) for now: a5b98009f16d moves the psi trigger write path under cgroup_mutex, which means the psimon kthread gets created while holding cgroup_mutex and introduces a deadlock risk.
Tejun has a follow-up fix for that which is in the cgroup tree but hasn't reached mainline yet. Once it lands, I'll queue your series together with it on all three branches.
Signature · 2 lines
Thanks, Sasha
Quoted 4 lines · Sasha Levin
I'm holding off on this series (and the 6.6.y/6.1.y ones) for now:
a5b98009f16dmoves the psi trigger write path undercgroup_mutex, which means the psimon kthread gets created while holdingcgroup_mutexand introduces a deadlock risk.
Thanks for the heads-up, Sasha, and sorry I missed the patch you pointed out.
BTW, I have an unrelated question. I'd like to backport some stable patches to earlier LTS trees (e.g. from 6.18 down to 6.6). For patchsets like this one that apply cleanly to multiple versions (6.1, 6.6, and 6.12), which of the following is preferred?
(1) A single patchset covering all three trees, with subjects like "[PATCH 6.1.y/6.6.y/6.12.y] ..."
(2) Three separate patchsets, one per stable tree.
Thanks.
Signature · 1 line
Philo
Sasha Levin
maintainerQuoted 9 lines
BTW, I have an unrelated question. I'd like to backport some stable patches to earlier LTS trees (e.g. from 6.18 down to 6.6). For patchsets like this one that apply cleanly to multiple versions (6.1, 6.6, and 6.12), which of the following is preferred?
(1) A single patchset covering all three trees, with subjects like "[PATCH 6.1.y/6.6.y/6.12.y] ..."
(2) Three separate patchsets, one per stable tree.
A single combined patchset is fine when the same patches apply cleanly to all the target trees - just list the versions in the subject like you described. Separate per-tree submissions are only needed when the backports diverge.
On this series: still holding for now - Tejun's fix for the psimon creation under cgroup_mutex hasn't landed in mainline yet. Once it does, I'll queue the series for 6.12, 6.6, and 6.1.
Signature · 2 lines
Thanks, Sasha