mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: "Günther Noack" <gnoack3000@gmail.com>
To: "Mickaël Salaün" <mic@digikod.net>
Cc: "Christian Brauner" <brauner@kernel.org>,
	"Günther Noack" <gnoack@google.com>,
	"Oleg Nesterov" <oleg@redhat.com>, "Tejun Heo" <tj@kernel.org>,
	"Bart Van Assche" <bvanassche@acm.org>,
	"Cen Zhang" <blbllhy@gmail.com>,
	"James Morris" <jmorris@namei.org>,
	"Lee Seong Hyeon" <ihopenre@gmail.com>,
	"Marco Elver" <elver@google.com>, NeilBrown <neil@brown.name>,
	"Nickolai Zeldovich" <nickolai@csail.mit.edu>,
	"Paul Moore" <paul@paul-moore.com>,
	"Peter Zijlstra" <peterz@infradead.org>,
	"Serge E . Hallyn" <serge@hallyn.com>,
	"Yihan Ding" <dingyihan@uniontech.com>,
	linux-kernel@vger.kernel.org,
	linux-security-module@vger.kernel.org, stable@vger.kernel.org
Subject: Re: [PATCH] landlock: Do not hold exec_update_lock across the TSYNC wait
Date: Sat, 21 Nov 2026 22:46:49 +0100	[thread overview]
Message-ID: <20261121.bd9ab1ba5f9f@gnoack.org> (raw)
In-Reply-To: <20261120151554.2651743-1-mic@digikod.net>

On Fri, Nov 20, 2026 at 04:15:52PM +0100, Mickaël Salaün wrote:
> 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.

It's not clear to me why the cleanup class and the fix are bundled in
one commit here.  (I do find the cleanup class useful, but shouldn't a
bugfix commit be as minimal as possible so that it is easy for people
to apply to their downstream kernels?)

–Günther

> - 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)(&current->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)(&current->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(&current->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(&current->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, &current->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
> 

      reply	other threads:[~2026-11-21 21:46 UTC|newest]

Thread overview: 2+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20 15:15 Mickaël Salaün
2026-11-21 21:46 ` Günther Noack [this message]

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261121.bd9ab1ba5f9f@gnoack.org \
    --to=gnoack3000@gmail.com \
    --cc=blbllhy@gmail.com \
    --cc=brauner@kernel.org \
    --cc=bvanassche@acm.org \
    --cc=dingyihan@uniontech.com \
    --cc=elver@google.com \
    --cc=gnoack@google.com \
    --cc=ihopenre@gmail.com \
    --cc=jmorris@namei.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-security-module@vger.kernel.org \
    --cc=mic@digikod.net \
    --cc=neil@brown.name \
    --cc=nickolai@csail.mit.edu \
    --cc=oleg@redhat.com \
    --cc=paul@paul-moore.com \
    --cc=peterz@infradead.org \
    --cc=serge@hallyn.com \
    --cc=stable@vger.kernel.org \
    --cc=tj@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®