* [PATCH] landlock: Do not hold exec_update_lock across the TSYNC wait
@ 2026-11-20 15:15 Mickaël Salaün
2026-11-20 15:22 ` sashiko-bot
0 siblings, 1 reply; 2+ messages in thread
From: Mickaël Salaün @ 2026-11-20 15:15 UTC (permalink / raw)
To: Christian Brauner, Günther Noack, Oleg Nesterov, Tejun Heo
Cc: Mickaël Salaün, Bart Van Assche, Cen Zhang,
James Morris, Lee Seong Hyeon, Marco Elver, NeilBrown,
Nickolai Zeldovich, Paul Moore, Peter Zijlstra, Serge E . Hallyn,
Yihan Ding, linux-kernel, linux-security-module, stable
landlock_restrict_sibling_threads() write-locks
current->signal->exec_update_lock to serialize TSYNC callers, and holds
it until every sibling thread has run its task_work. This wait is
unbounded: TWA_SIGNAL does not wake a TASK_KILLABLE sleeper, so a
sibling blocked as a vfork() parent runs it only once its child execs or
exits.
Meanwhile, readers of this lock block, mostly in D state:
/proc/<pid>/stat, mm_access(), pidfd_getfd(), kcmp(), perf_event_open(),
etc. An unprivileged process can thus stall tools run by other users,
including root, such as ps and top.
Only a per-process "TSYNC in progress" marker is needed. Use an unused
signal_struct.flags bit, protected by sighand->siglock, which is held
only to set or clear the marker. A second caller still restarts the
syscall, and a cleanup class releases the marker on every return.
Like de_thread(), treat a group exit or an ongoing exec as a held
marker: a group exit may overwrite the flags, and both kill the other
threads, which the restart lets the caller handle.
Add KUnit tests for taking a free marker and for rejecting a held one.
A concurrent TSYNC caller cannot be started deterministically from user
space, but a KUnit thread has no sibling and can hold the marker itself.
Cc: Christian Brauner <brauner@kernel.org>
Cc: Günther Noack <gnoack@google.com>
Cc: Nickolai Zeldovich <nickolai@csail.mit.edu>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Yihan Ding <dingyihan@uniontech.com>
Cc: stable@vger.kernel.org
Reported-by: Lee Seong Hyeon <ihopenre@gmail.com>
Suggested-by: Lee Seong Hyeon <ihopenre@gmail.com>
Fixes: ff88df67dbf7 ("landlock: Serialize TSYNC thread restriction")
Signed-off-by: Mickaël Salaün <mic@digikod.net>
---
Changes since the initial report from Lee Seong Hyeon:
- Rewrite the fix, storing the marker in an unused signal_struct.flags
bit protected by sighand->siglock instead of adding a signal_struct
field.
- Treat group exit and ongoing exec as a held marker, because group exit
may overwrite the flags.
- Release the marker with a cleanup class.
- Clarify that not all readers wait in D state: perf_event_open() waits
interruptibly.
- Add KUnit tests.
- Credit Lee Seong Hyeon with Reported-by and Suggested-by instead of
authorship, because the implementation was rewritten.
Christian, Oleg, and Tejun, this patch reserves a signal_struct.flags
bit for Landlock and relies on group-exit paths overwriting these flags
under siglock. Please check that this use of signal-core state is
acceptable.
Lee, this rewrites the patch you sent with your report, so it credits
you with Reported-by and Suggested-by. Please tell me if you prefer a
different credit.
---
include/linux/sched/signal.h | 1 +
security/landlock/tsync.c | 134 +++++++++++++++++++++++++++++++----
2 files changed, 122 insertions(+), 13 deletions(-)
diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 0adb51ab1542..f68bbaa3527a 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -262,6 +262,7 @@ struct signal_struct {
#define SIGNAL_STOP_STOPPED 0x00000001 /* job control stop in effect */
#define SIGNAL_STOP_CONTINUED 0x00000002 /* SIGCONT since WCONTINUED reap */
#define SIGNAL_GROUP_EXIT 0x00000004 /* group exit in progress */
+#define SIGNAL_LANDLOCK_TSYNC 0x00000008 /* Landlock TSYNC in progress */
/*
* Pending notifications to parent.
*/
diff --git a/security/landlock/tsync.c b/security/landlock/tsync.c
index cfa73a2a67ca..a6fa9ce0ac78 100644
--- a/security/landlock/tsync.c
+++ b/security/landlock/tsync.c
@@ -5,6 +5,7 @@
* Copyright © 2025 Google LLC
*/
+#include <kunit/test.h>
#include <linux/atomic.h>
#include <linux/cleanup.h>
#include <linux/completion.h>
@@ -479,6 +480,46 @@ static void cancel_tsync_works(const struct tsync_works *works,
}
}
+/*
+ * try_set_current_tsync_marker - mark the current thread group as under TSYNC
+ *
+ * Returns false if another TSYNC operation, group exit, or exec is in progress.
+ */
+static bool try_set_current_tsync_marker(void)
+{
+ struct signal_struct *const signal = current->signal;
+
+ guard(spinlock_irq)(¤t->sighand->siglock);
+
+ /*
+ * Group-exit paths may replace all signal flags, including an active
+ * marker. Treat SIGNAL_GROUP_EXIT as a held marker to prevent another
+ * TSYNC operation from starting during group teardown.
+ *
+ * Like de_thread(), also treat an ongoing exec as a group action in
+ * progress. de_thread() sets group_exec_task in the same siglock
+ * critical section that sends SIGKILL to all other threads, including
+ * current. Instead of queuing task_work for exiting threads,
+ * restart_syscall() lets current handle its pending SIGKILL.
+ */
+ if ((signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_LANDLOCK_TSYNC)) ||
+ signal->group_exec_task)
+ return false;
+
+ signal->flags |= SIGNAL_LANDLOCK_TSYNC;
+ return true;
+}
+
+static void clear_current_tsync_marker(void)
+{
+ guard(spinlock_irq)(¤t->sighand->siglock);
+
+ current->signal->flags &= ~SIGNAL_LANDLOCK_TSYNC;
+}
+
+DEFINE_CLASS(current_tsync_marker, bool, if (_T) clear_current_tsync_marker(),
+ try_set_current_tsync_marker(), void)
+
/*
* restrict_sibling_threads - enables a Landlock policy for all sibling threads
*/
@@ -492,6 +533,19 @@ int landlock_restrict_sibling_threads(const struct cred *old_cred,
size_t newly_discovered_threads;
bool found_more_threads;
+ /*
+ * Serialize concurrent TSYNC operations to prevent deadlocks when
+ * multiple threads call landlock_restrict_self() simultaneously. If
+ * another operation got there first, gracefully yield by restarting the
+ * syscall. This allows the current thread to process pending
+ * task_works before retrying.
+ *
+ * sighand->siglock protects only the marker, not the wait below.
+ */
+ CLASS(current_tsync_marker, marker)();
+ if (!marker)
+ return restart_syscall();
+
atomic_set(&shared_ctx.preparation_error, 0);
init_completion(&shared_ctx.all_prepared);
init_completion(&shared_ctx.ready_to_commit);
@@ -503,16 +557,6 @@ int landlock_restrict_sibling_threads(const struct cred *old_cred,
(restrict_flags & LANDLOCK_RESTRICT_SELF_NO_NEW_PRIVS) ||
task_no_new_privs(current);
- /*
- * Serialize concurrent TSYNC operations to prevent deadlocks when
- * multiple threads call landlock_restrict_self() simultaneously.
- * If the lock is already held, we gracefully yield by restarting the
- * syscall. This allows the current thread to process pending
- * task_works before retrying.
- */
- if (!down_write_trylock(¤t->signal->exec_update_lock))
- return restart_syscall();
-
/*
* We schedule a pseudo-signal task_work for each of the calling task's
* sibling threads. In the task work, each thread:
@@ -536,8 +580,9 @@ int landlock_restrict_sibling_threads(const struct cred *old_cred,
* 5) signals that it's done altogether (barrier synchronization
* "all_finished")
*
- * Unlike seccomp, which modifies sibling tasks directly, we do not
- * need to acquire the cred_guard_mutex and sighand->siglock:
+ * Unlike seccomp, which modifies sibling tasks directly, we do not need
+ * to hold the cred_guard_mutex or sighand->siglock around the thread
+ * walk:
*
* - As in our case, all threads are themselves exchanging their own
* struct cred through the credentials API, no locks are needed for
@@ -634,6 +679,69 @@ int landlock_restrict_sibling_threads(const struct cred *old_cred,
wait_for_completion(&shared_ctx.all_finished);
tsync_works_release(&works);
- up_write(¤t->signal->exec_update_lock);
return atomic_read(&shared_ctx.preparation_error);
}
+
+#ifdef CONFIG_SECURITY_LANDLOCK_KUNIT_TEST
+
+static bool is_current_tsync_marker_set(void)
+{
+ return current->signal->flags & SIGNAL_LANDLOCK_TSYNC;
+}
+
+static void test_tsync_marker_free(struct kunit *const test)
+{
+ const struct cred *const cred = current_cred();
+
+ KUNIT_ASSERT_TRUE(test, thread_group_empty(current));
+ KUNIT_ASSERT_FALSE(test, is_current_tsync_marker_set());
+
+ KUNIT_EXPECT_TRUE(test, try_set_current_tsync_marker());
+ KUNIT_EXPECT_TRUE(test, is_current_tsync_marker_set());
+ clear_current_tsync_marker();
+ KUNIT_EXPECT_FALSE(test, is_current_tsync_marker_set());
+
+ /* Takes and releases the marker. */
+ KUNIT_EXPECT_EQ(test, 0,
+ landlock_restrict_sibling_threads(cred, cred, 0));
+ KUNIT_EXPECT_FALSE(test, is_current_tsync_marker_set());
+}
+
+static void test_tsync_marker_held(struct kunit *const test)
+{
+ const struct cred *const cred = current_cred();
+
+ KUNIT_ASSERT_TRUE(test, thread_group_empty(current));
+ KUNIT_ASSERT_TRUE(test, try_set_current_tsync_marker());
+
+ KUNIT_EXPECT_FALSE(test, try_set_current_tsync_marker());
+ KUNIT_EXPECT_TRUE(test, is_current_tsync_marker_set());
+
+ /* Restarts without releasing the marker held by another caller. */
+ KUNIT_EXPECT_EQ(test, -ERESTARTNOINTR,
+ landlock_restrict_sibling_threads(cred, cred, 0));
+ KUNIT_EXPECT_TRUE(test, is_current_tsync_marker_set());
+
+ /* Clears TIF_SIGPENDING set by restart_syscall(). */
+ scoped_guard(spinlock_irq, ¤t->sighand->siglock)
+ recalc_sigpending();
+
+ clear_current_tsync_marker();
+}
+
+static struct kunit_case test_cases[] = {
+ /* clang-format off */
+ KUNIT_CASE(test_tsync_marker_free),
+ KUNIT_CASE(test_tsync_marker_held),
+ {}
+ /* clang-format on */
+};
+
+static struct kunit_suite test_suite = {
+ .name = "landlock_tsync",
+ .test_cases = test_cases,
+};
+
+kunit_test_suite(test_suite);
+
+#endif /* CONFIG_SECURITY_LANDLOCK_KUNIT_TEST */
base-commit: aebb7274476403040d582c61478df8f4a7bf9cd3
--
2.56.0
^ permalink raw reply related [flat|nested] 2+ messages in thread
* Re: [PATCH] landlock: Do not hold exec_update_lock across the TSYNC wait
2026-11-20 15:15 [PATCH] landlock: Do not hold exec_update_lock across the TSYNC wait Mickaël Salaün
@ 2026-11-20 15:22 ` sashiko-bot
0 siblings, 0 replies; 2+ messages in thread
From: sashiko-bot @ 2026-11-20 15:22 UTC (permalink / raw)
Cc: linux-security-module
> landlock_restrict_sibling_threads() write-locks
> current->signal->exec_update_lock to serialize TSYNC callers, and holds
> it until every sibling thread has run its task_work. This wait is
> unbounded: TWA_SIGNAL does not wake a TASK_KILLABLE sleeper, so a
> sibling blocked as a vfork() parent runs it only once its child execs or
> exits.
>
> Meanwhile, readers of this lock block, mostly in D state:
> /proc/<pid>/stat, mm_access(), pidfd_getfd(), kcmp(), perf_event_open(),
> etc. An unprivileged process can thus stall tools run by other users,
> including root, such as ps and top.
>
> Only a per-process "TSYNC in progress" marker is needed. Use an unused
> signal_struct.flags bit, protected by sighand->siglock, which is held
> only to set or clear the marker. A second caller still restarts the
> [ ... ]
> Cc: stable@vger.kernel.org
> Reported-by: Lee Seong Hyeon <ihopenre@gmail.com>
> Suggested-by: Lee Seong Hyeon <ihopenre@gmail.com>
> Fixes: ff88df67dbf7 ("landlock: Serialize TSYNC thread restriction")
> Signed-off-by: Mickaël Salaün <mic@digikod.net>
Sashiko has reviewed this patch and found no issues.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261120151554.2651743-1-mic@digikod.net?part=1
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-11-20 15:22 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 15:15 [PATCH] landlock: Do not hold exec_update_lock across the TSYNC wait Mickaël Salaün
2026-11-20 15:22 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox