Skip to contentSkip to conversation

sched/psi: fix race in pressure_write (CVE-2026-52991)

PATCH In review Philo Lu 2 participants 6 messages Jul 15 – Jul 19

Subsystems (2)
lore
Share & tools
lore

Philo Lu

author
#0 lore raw

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

author
#1 lore raw

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
index 3c7d466f13df7..3ce02650f9484 100644
@@ -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
author
#2 lore raw

PATCH 2/2 sched/psi: fix race between file release and pressure write

In reply to Philo Lu

From: 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
index 3ce02650f9484..693959a6b2f3e 100644
@@ -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
maintainer
#3 lore raw
In reply to Philo Lu
Quoted 7 lines · Philo Lu

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].

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
author
#4 lore raw
Quoted 4 lines · Sasha Levin

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.

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
maintainer
#5 lore raw
Quoted 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