seccomp: avoid the lock trip seccomp_filter_release in common case

Vast majority of threads don't have any seccomp filters, all while the
lock taken here is shared between all threads in given process and
frequently used.

Safety of the check relies on the following:
- seccomp_filter_release is only legally called for PF_EXITING threads
- SIGNAL_GROUP_EXIT is only ever set with the sighand lock held
- PF_EXITING is only ever set with the sighand lock held *or* after
  SIGNAL_GROUP_EXIT is set *or* the process is single-threaded
- seccomp_sync_threads holds the sighand lock and skips all threads if
  SIGNAL_GROUP_EXIT is set, PF_EXITING threads if not

Resulting reduction of contention gives me a 5% boost in a
microbenchmark spawning and killing threads within the same process.

Signed-off-by: Mateusz Guzik <mjguzik@gmail.com>
Link: https://lore.kernel.org/r/20250213170911.1140187-1-mjguzik@gmail.com
Signed-off-by: Kees Cook <kees@kernel.org>

diff --git a/kernel/seccomp.c b/kernel/seccomp.c
index 0ce17c6161506ee374f90e4550f05f8576a9170b..41aa761c7738cefe01ca755f78f12844d7186e2a 100644 (file)
--- a/kernel/seccomp.c
+++ b/kernel/seccomp.c
@@ -574,6 +574,9 @@ void seccomp_filter_release(struct task_struct *tsk)
        if (WARN_ON((tsk->flags & PF_EXITING) == 0))
                return;
 
+       if (READ_ONCE(tsk->seccomp.filter) == NULL)
+               return;
+
        spin_lock_irq(&tsk->sighand->siglock);
        orig = tsk->seccomp.filter;
        /* Detach task from its filter tree. */
@@ -599,6 +602,13 @@ static inline void seccomp_sync_threads(unsigned long flags)
        BUG_ON(!mutex_is_locked(&current->signal->cred_guard_mutex));
        assert_spin_locked(&current->sighand->siglock);
 
+       /*
+        * Don't touch any of the threads if the process is being killed.
+        * This allows for a lockless check in seccomp_filter_release.
+        */
+       if (current->signal->flags & SIGNAL_GROUP_EXIT)
+               return;
+
        /* Synchronize all threads. */
        caller = current;
        for_each_thread(caller, thread) {