FAILED: patch "[PATCH] tracing/user_events: Fix use-after-free in" failed to apply to 6.6-stable tree
Subsystems (2)
[email protected]
maintainerThe patch below does not apply to the 6.6-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.6.y
git checkout FETCH_HEAD
git cherry-pick -x 50fd6dd755c6e48a38af2fa4621167eea56829c2
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '2026072054-anywhere-moodiness-9087@gregkh' --subject-prefix 'PATCH 6.6.y' 'HEAD^..'
Possible dependencies:
thanks,
greg k-h
------------------ original commit in Linus's tree ------------------
From 50fd6dd755c6e48a38af2fa4621167eea56829c2 Mon Sep 17 00:00:00 2001
From: Michael Bommarito <[email protected]>
Date: Tue, 7 Jul 2026 12:59:11 -0400
Subject: [PATCH] tracing/user_events: Fix use-after-free in
user_event_mm_dup()
user_event_mm_dup() walks the parent mm's enabler list locklessly under rcu_read_lock() during fork() (from copy_process()); it does not take event_mutex:
rcu_read_lock(); list_for_each_entry_rcu(enabler, &old_mm->enablers, mm_enablers_link) enabler->event = user_event_get(orig->event);
user_event_enabler_destroy() removes an enabler from that list with list_del_rcu() and then, without waiting for a grace period, drops the enabler's user_event reference with user_event_put() and frees the enabler with kfree(). A reader that loaded the enabler before the list_del_rcu() can still be walking it, which leads to two use-after-frees:
- kfree(enabler) frees the enabler while that reader dereferences enabler->event.
- user_event_put() may drop the last reference to the user_event, which is then freed (via delayed_destroy_user_event() on a work queue), while the same reader does user_event_get(orig->event) on it.
Both are reachable by an unprivileged task that can open user_events_data:
one multithreaded process that registers an enabler and then concurrently unregisters it and calls fork() triggers the race. KASAN reports a slab-use-after-free in user_event_mm_dup() during clone(), with a "refcount_t: addition on 0" warning when the user_event is freed.
The enabler use-after-free was found first; the user_event one was reported by XIAO WU, and the earlier enabler-only fix did not address it.
Defer both the user_event_put() and the kfree(enabler) to a work item queued with queue_rcu_work(), so they run only after an RCU grace period, once all readers walking the enabler list have finished. The put must run in process context because user_event_put() takes event_mutex on the last reference, so a work queue is used rather than call_rcu(). The now-unlocked put lets the locked argument of user_event_enabler_destroy() be removed; all callers are updated.
kernel/trace/trace_events_user.c +34 -9
@@ -109,6 +109,9 @@ struct user_event_enabler {/* Track enable bit, flags, etc. Aligned for bitops. */ unsigned long values; + +/* Defer the event put and enabler free past an RCU grace period. */ +struct rcu_work put_rwork; };/* Bits 0-5 are for the bit to update upon enable/disable (0-63 allowed) */
@@ -396,15 +399,37 @@ static struct user_event_group *user_event_group_create(void)return NULL ; }; -static void user_event_enabler_destroy (struct user_event_enabler *enabler, -bool locked) +static void delayed_user_event_enabler_put (struct work_struct *work) +{ +struct user_event_enabler *enabler =container_of (to_rcu_work (work), + struct user_event_enabler, put_rwork); + +/* No longer tracking the event via the enabler */ +user_event_put (enabler->event, false); + +/* Run from queue_rcu_work(), the RCU grace period has elapsed */ +kfree (enabler); +} + +static void user_event_enabler_destroy (struct user_event_enabler *enabler) {list_del_rcu (&enabler->mm_enablers_link); -/* No longer tracking the event via the enabler */ -user_event_put (enabler->event, locked); - -kfree (enabler); +/* +* The enabler is removed from an RCU-traversed list +* (user_event_mm_dup() walks mm->enablers under rcu_read_lock() only), +* and readers there dereference enabler->event and take a new ref on +* it. Both the put of that event reference and the free of the enabler +* therefore have to wait for a grace period so no reader can be looking +* at the enabler or racing the last put of its event. +* +* The put itself must not run in RCU context: when it drops the last +* reference user_event_put() takes event_mutex, which cannot be taken +* from a softirq/RCU callback. Defer both to a work item scheduled +* after a grace period via queue_rcu_work(). +*/ +INIT_RCU_WORK (&enabler->put_rwork, delayed_user_event_enabler_put); +queue_rcu_work (system_percpu_wq, &enabler->put_rwork); } static int user_event_mm_fault_in(struct user_event_mm *mm, unsigned long uaddr,
@@ -464,7 +489,7 @@ static void user_event_enabler_fault_fixup(struct work_struct *work)/* User asked for enabler to be removed during fault */ if (test_bit (ENABLE_VAL_FREEING_BIT ,ENABLE_BITOPS (enabler))) { -user_event_enabler_destroy (enabler, true); +user_event_enabler_destroy (enabler); goto out; }
@@ -764,7 +789,7 @@ static void user_event_mm_destroy(struct user_event_mm *mm)struct user_event_enabler *enabler, *next;list_for_each_entry_safe (enabler, next, &mm->enablers, mm_enablers_link) -user_event_enabler_destroy (enabler, false); +user_event_enabler_destroy (enabler);mmdrop (mm->mm);kfree (mm);
@@ -2645,7 +2670,7 @@ static long user_events_ioctl_unreg(unsigned long uarg) flags |= enabler->values &ENABLE_VAL_COMPAT_MASK ;if (!test_bit (ENABLE_VAL_FAULTING_BIT ,ENABLE_BITOPS (enabler))) -user_event_enabler_destroy (enabler, true); +user_event_enabler_destroy (enabler);/* Removed at least one */ ret =0 ;
Sasha Levin
maintainerPATCH 1/3 workqueue: Factor out init_cpu_worker_pool()
From: Tejun Heo <[email protected]>
[ Upstream commit 2fcdb1b44491e08f5334a92c50e8f362e0d46f91 ]
Factor out init_cpu_worker_pool() from workqueue_init_early(). This is pure reorganization in preparation of BH workqueue support.
Stable-dep-of: 50fd6dd755c6 ("tracing/user_events: Fix use-after-free in user_event_mm_dup()")
--- kernel/workqueue.c | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-)
kernel/workqueue.c +18 -14
@@ -6609,6 +6609,22 @@ static void __init restrict_unbound_cpumask(const char *name, const struct cpumacpumask_and (wq_unbound_cpumask, wq_unbound_cpumask, mask); } +static void __init init_cpu_worker_pool (struct worker_pool *pool,int cpu,int nice) +{ +BUG_ON (init_worker_pool (pool)); + pool->cpu = cpu; +cpumask_copy (pool->attrs->cpumask,cpumask_of (cpu)); +cpumask_copy (pool->attrs->__pod_cpumask,cpumask_of (cpu)); + pool->attrs->nice = nice; + pool->attrs->affn_strict = true; + pool->node =cpu_to_node (cpu); + +/* alloc pool ID */ +mutex_lock (&wq_pool_mutex); +BUG_ON (worker_pool_assign_id (pool)); +mutex_unlock (&wq_pool_mutex); +} +/** * workqueue_init_early - early init for workqueue subsystem *
@@ -6657,20 +6673,8 @@ void __init workqueue_init_early(void)struct worker_pool *pool; i =0 ; -for_each_cpu_worker_pool (pool, cpu) { -BUG_ON (init_worker_pool (pool)); - pool->cpu = cpu; -cpumask_copy (pool->attrs->cpumask,cpumask_of (cpu)); -cpumask_copy (pool->attrs->__pod_cpumask,cpumask_of (cpu)); - pool->attrs->nice = std_nice[i++]; - pool->attrs->affn_strict = true; - pool->node =cpu_to_node (cpu); - -/* alloc pool ID */ -mutex_lock (&wq_pool_mutex); -BUG_ON (worker_pool_assign_id (pool)); -mutex_unlock (&wq_pool_mutex); - } +for_each_cpu_worker_pool (pool, cpu) +init_cpu_worker_pool (pool, cpu, std_nice[i++]); }/* create default unbound and ordered wq attrs */
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/3 workqueue: Add system_percpu_wq and system_dfl_wq
From: Marco Crivellari <[email protected]>
[ Upstream commit 128ea9f6ccfb6960293ae4212f4f97165e42222d ]
Currently, if a user enqueue a work item using schedule_delayed_work() the used wq is "system_wq" (per-cpu wq) while queue_delayed_work() use WORK_CPU_UNBOUND (used when a cpu is not specified). The same applies to schedule_work() that is using system_wq and queue_work(), that makes use again of WORK_CPU_UNBOUND.
This lack of consistentcy cannot be addressed without refactoring the API.
system_wq is a per-CPU worqueue, yet nothing in its name tells about that CPU affinity constraint, which is very often not required by users. Make it clear by adding a system_percpu_wq.
system_unbound_wq should be the default workqueue so as not to enforce locality constraints for random work whenever it's not required.
Adding system_dfl_wq to encourage its use when unbound work should be used.
Stable-dep-of: 50fd6dd755c6 ("tracing/user_events: Fix use-after-free in user_event_mm_dup()")
--- include/linux/workqueue.h | 8 +++++--- kernel/workqueue.c | 14 ++++++++++---- 2 files changed, 15 insertions(+), 7 deletions(-)
include/linux/workqueue.h +5 -3
@@ -410,7 +410,7 @@ enum {/* * System-wide workqueues which are always present. * -* system_wq is the one used by schedule[_delayed]_work[_on](). +* system_percpu_wq is the one used by schedule[_delayed]_work[_on](). * Multi-CPU multi-threaded. There are users which expect relatively * short queue flush time. Don't queue works which can run for too * long.
@@ -421,7 +421,7 @@ enum {* system_long_wq is similar to system_wq but may host long running * works. Queue flushing might take relatively long. * -* system_unbound_wq is unbound workqueue. Workers are not bound to +* system_dfl_wq is unbound workqueue. Workers are not bound to * any specific CPU, not concurrency managed, and all queued works are * executed immediately as long as max_active limit is not reached and * resources are available.
@@ -435,10 +435,12 @@ enum {* system_power_efficient_wq is identical to system_wq if * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info. */ -extern struct workqueue_struct *system_wq; +extern struct workqueue_struct *system_wq;/* use system_percpu_wq, this will be removed */ +extern struct workqueue_struct *system_percpu_wq;extern struct workqueue_struct *system_highpri_wq;extern struct workqueue_struct *system_long_wq;extern struct workqueue_struct *system_unbound_wq; +extern struct workqueue_struct *system_dfl_wq;extern struct workqueue_struct *system_freezable_wq;extern struct workqueue_struct *system_power_efficient_wq;extern struct workqueue_struct *system_freezable_power_efficient_wq;
kernel/workqueue.c +10 -4
@@ -425,12 +425,16 @@ static struct kthread_worker *pwq_release_worker;struct workqueue_struct *system_wq__read_mostly ;EXPORT_SYMBOL (system_wq); +struct workqueue_struct *system_percpu_wq__read_mostly ; +EXPORT_SYMBOL (system_percpu_wq);struct workqueue_struct *system_highpri_wq__read_mostly ;EXPORT_SYMBOL_GPL (system_highpri_wq);struct workqueue_struct *system_long_wq__read_mostly ;EXPORT_SYMBOL_GPL (system_long_wq);struct workqueue_struct *system_unbound_wq__read_mostly ;EXPORT_SYMBOL_GPL (system_unbound_wq); +struct workqueue_struct *system_dfl_wq__read_mostly ; +EXPORT_SYMBOL_GPL (system_dfl_wq);struct workqueue_struct *system_freezable_wq__read_mostly ;EXPORT_SYMBOL_GPL (system_freezable_wq);struct workqueue_struct *system_power_efficient_wq__read_mostly ;
@@ -6696,10 +6700,11 @@ void __init workqueue_init_early(void) } system_wq =alloc_workqueue ("events" ,0 ,0 ); + system_percpu_wq =alloc_workqueue ("events" ,0 ,0 ); system_highpri_wq =alloc_workqueue ("events_highpri" ,WQ_HIGHPRI ,0 ); system_long_wq =alloc_workqueue ("events_long" ,0 ,0 ); - system_unbound_wq =alloc_workqueue ("events_unbound" ,WQ_UNBOUND , -WQ_MAX_ACTIVE ); + system_unbound_wq =alloc_workqueue ("events_unbound" ,WQ_UNBOUND ,WQ_MAX_ACTIVE ); + system_dfl_wq =alloc_workqueue ("events_unbound" ,WQ_UNBOUND ,WQ_MAX_ACTIVE ); system_freezable_wq =alloc_workqueue ("events_freezable" ,WQ_FREEZABLE ,0 ); system_power_efficient_wq = alloc_workqueue("events_power_efficient",
@@ -6707,8 +6712,9 @@ void __init workqueue_init_early(void) system_freezable_power_efficient_wq =alloc_workqueue ("events_freezable_power_efficient" ,WQ_FREEZABLE |WQ_POWER_EFFICIENT ,0 ); -BUG_ON (!system_wq || !system_highpri_wq || !system_long_wq || - !system_unbound_wq || !system_freezable_wq || +BUG_ON (!system_wq || !system_percpu_wq || !system_highpri_wq || + !system_long_wq || !system_unbound_wq || !system_dfl_wq || + !system_freezable_wq || !system_power_efficient_wq || !system_freezable_power_efficient_wq); }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/3 tracing/user_events: Fix use-after-free in user_event_mm_dup()
In reply to Sasha LevinFrom: Michael Bommarito <[email protected]>
[ Upstream commit 50fd6dd755c6e48a38af2fa4621167eea56829c2 ]
user_event_mm_dup() walks the parent mm's enabler list locklessly under rcu_read_lock() during fork() (from copy_process()); it does not take event_mutex:
rcu_read_lock(); list_for_each_entry_rcu(enabler, &old_mm->enablers, mm_enablers_link) enabler->event = user_event_get(orig->event);
user_event_enabler_destroy() removes an enabler from that list with list_del_rcu() and then, without waiting for a grace period, drops the enabler's user_event reference with user_event_put() and frees the enabler with kfree(). A reader that loaded the enabler before the list_del_rcu() can still be walking it, which leads to two use-after-frees:
- kfree(enabler) frees the enabler while that reader dereferences enabler->event.
- user_event_put() may drop the last reference to the user_event, which is then freed (via delayed_destroy_user_event() on a work queue), while the same reader does user_event_get(orig->event) on it.
Both are reachable by an unprivileged task that can open user_events_data:
one multithreaded process that registers an enabler and then concurrently unregisters it and calls fork() triggers the race. KASAN reports a slab-use-after-free in user_event_mm_dup() during clone(), with a "refcount_t: addition on 0" warning when the user_event is freed.
The enabler use-after-free was found first; the user_event one was reported by XIAO WU, and the earlier enabler-only fix did not address it.
Defer both the user_event_put() and the kfree(enabler) to a work item queued with queue_rcu_work(), so they run only after an RCU grace period, once all readers walking the enabler list have finished. The put must run in process context because user_event_put() takes event_mutex on the last reference, so a work queue is used rather than call_rcu(). The now-unlocked put lets the locked argument of user_event_enabler_destroy() be removed; all callers are updated.
--- kernel/trace/trace_events_user.c | 39 ++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 7 deletions(-)
kernel/trace/trace_events_user.c +32 -7
@@ -104,6 +104,9 @@ struct user_event_enabler {/* Track enable bit, flags, etc. Aligned for bitops. */ unsigned long values; + +/* Defer the event put and enabler free past an RCU grace period. */ +struct rcu_work put_rwork; };/* Bits 0-5 are for the bit to update upon enable/disable (0-63 allowed) */
@@ -378,17 +381,39 @@ static struct user_event_group *user_event_group_create(void)return NULL ; }; -static void user_event_enabler_destroy (struct user_event_enabler *enabler, -bool locked) +static void delayed_user_event_enabler_put (struct work_struct *work) { -list_del_rcu (&enabler->mm_enablers_link); +struct user_event_enabler *enabler =container_of (to_rcu_work (work), + struct user_event_enabler, put_rwork);/* No longer tracking the event via the enabler */ -user_event_put (enabler->event, locked); +user_event_put (enabler->event, false); +/* Run from queue_rcu_work(), the RCU grace period has elapsed */ kfree (enabler); } +static void user_event_enabler_destroy (struct user_event_enabler *enabler) +{ +list_del_rcu (&enabler->mm_enablers_link); + +/* +* The enabler is removed from an RCU-traversed list +* (user_event_mm_dup() walks mm->enablers under rcu_read_lock() only), +* and readers there dereference enabler->event and take a new ref on +* it. Both the put of that event reference and the free of the enabler +* therefore have to wait for a grace period so no reader can be looking +* at the enabler or racing the last put of its event. +* +* The put itself must not run in RCU context: when it drops the last +* reference user_event_put() takes event_mutex, which cannot be taken +* from a softirq/RCU callback. Defer both to a work item scheduled +* after a grace period via queue_rcu_work(). +*/ +INIT_RCU_WORK (&enabler->put_rwork, delayed_user_event_enabler_put); +queue_rcu_work (system_percpu_wq, &enabler->put_rwork); +} +static int user_event_mm_fault_in (struct user_event_mm *mm,unsigned long uaddr,int attempt) {
@@ -446,7 +471,7 @@ static void user_event_enabler_fault_fixup(struct work_struct *work)/* User asked for enabler to be removed during fault */ if (test_bit (ENABLE_VAL_FREEING_BIT ,ENABLE_BITOPS (enabler))) { -user_event_enabler_destroy (enabler, true); +user_event_enabler_destroy (enabler); goto out; }
@@ -746,7 +771,7 @@ static void user_event_mm_destroy(struct user_event_mm *mm)struct user_event_enabler *enabler, *next;list_for_each_entry_safe (enabler, next, &mm->enablers, mm_enablers_link) -user_event_enabler_destroy (enabler, false); +user_event_enabler_destroy (enabler);mmdrop (mm->mm);kfree (mm);
@@ -2579,7 +2604,7 @@ static long user_events_ioctl_unreg(unsigned long uarg) flags |= enabler->values &ENABLE_VAL_COMPAT_MASK ;if (!test_bit (ENABLE_VAL_FAULTING_BIT ,ENABLE_BITOPS (enabler))) -user_event_enabler_destroy (enabler, true); +user_event_enabler_destroy (enabler);/* Removed at least one */ ret =0 ;
Signature · 1 line
2.53.0