git: 9823ecaea3c0 - releng/14.4 - kqueue: Fix a race when detaching a timer knote
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Tue, 17 Nov 2026 17:04:14 UTC
The branch releng/14.4 has been updated by markj:
URL: https://cgit.FreeBSD.org/src/commit/?id=9823ecaea3c0e9d0bdf0d847a4d8155dbbaac80c
commit 9823ecaea3c0e9d0bdf0d847a4d8155dbbaac80c
Author: Mark Johnston <markj@FreeBSD.org>
AuthorDate: 2026-11-12 19:16:53 +0000
Commit: Mark Johnston <markj@FreeBSD.org>
CommitDate: 2026-11-16 21:16:22 +0000
kqueue: Fix a race when detaching a timer knote
We currently maintain a per-process list of stopped timer knotes, used
when the owning process receives SIGSTOP. Upon receiving SIGCONT,
queued timers are re-armed.
When detaching a timer knote, we drain the callout and remove it from
the queue, then check to see if the callout was re-armed by SIGCONT; if
so, then we loop. However, the callout timer may fire before this
check, and softclock_call_cc() clears the pending bit without the
associated callout lock held, in which case filt_timerdetach() fails to
observe that the callout is still running and doesn't drain.
The callout handler then races with a free of the knote, and the
resulting memory corruption can be exploited to obtain root privileges.
Fix the problem by using an explicit flag that prevents re-arming a
timer whose knote is in the process of being detached.
Approved by: so
Security: FreeBSD-SA-26:85.kqueue
Security: CVE-2026-101320
Reported by: OpenAI Security Research Team
Fixes: 2fd1ffefaa4d ("Stop arming kqueue timers on knote owner suspend or terminate")
Sponsored by: The FreeBSD Foundation
Reviewed by: kib
Differential Revision: https://reviews.freebsd.org/D61359
---
sys/kern/kern_event.c | 30 ++++++++++++------------------
1 file changed, 12 insertions(+), 18 deletions(-)
diff --git a/sys/kern/kern_event.c b/sys/kern/kern_event.c
index c937505a7270..43ba760c7f2a 100644
--- a/sys/kern/kern_event.c
+++ b/sys/kern/kern_event.c
@@ -698,7 +698,8 @@ struct kq_timer_cb_data {
sbintime_t to; /* precalculated timer period, 0 for abs */
};
-#define KQ_TIMER_CB_ENQUEUED 0x01
+#define KQ_TIMER_CB_ENQUEUED 0x01 /* in queue of stopped timers */
+#define KQ_TIMER_CB_DETACHING 0x02 /* detach started, don't requeue */
static void
kqtimer_sched_callout(struct kq_timer_cb_data *kc)
@@ -766,7 +767,8 @@ filt_timerexpire_l(struct knote *kn, bool proc_locked)
if (!proc_locked)
PROC_LOCK(p);
if (P_SHOULDSTOP(p) || P_KILLED(p)) {
- if ((kc->flags & KQ_TIMER_CB_ENQUEUED) == 0) {
+ if ((kc->flags & (KQ_TIMER_CB_ENQUEUED |
+ KQ_TIMER_CB_DETACHING)) == 0) {
/*
* Insert into head so that
* kqtimer_proc_continue() does not
@@ -879,24 +881,16 @@ filt_timerdetach(struct knote *kn)
{
struct kq_timer_cb_data *kc;
unsigned int old __unused;
- bool pending;
kc = kn->kn_ptr.p_v;
- do {
- callout_drain(&kc->c);
-
- /*
- * kqtimer_proc_continue() might have rescheduled this callout.
- * Double-check, using the process mutex as an interlock.
- */
- PROC_LOCK(kc->p);
- if ((kc->flags & KQ_TIMER_CB_ENQUEUED) != 0) {
- kc->flags &= ~KQ_TIMER_CB_ENQUEUED;
- TAILQ_REMOVE(&kc->p->p_kqtim_stop, kc, link);
- }
- pending = callout_pending(&kc->c);
- PROC_UNLOCK(kc->p);
- } while (pending);
+ PROC_LOCK(kc->p);
+ kc->flags |= KQ_TIMER_CB_DETACHING;
+ if ((kc->flags & KQ_TIMER_CB_ENQUEUED) != 0) {
+ kc->flags &= ~KQ_TIMER_CB_ENQUEUED;
+ TAILQ_REMOVE(&kc->p->p_kqtim_stop, kc, link);
+ }
+ PROC_UNLOCK(kc->p);
+ callout_drain(&kc->c);
free(kc, M_KQUEUE);
old = atomic_fetchadd_int(&kq_ncallouts, -1);
KASSERT(old > 0, ("Number of callouts cannot become negative"));