From nobody Mon Nov 25 02:39:21 2024 Received: from galois.linutronix.de (Galois.linutronix.de [193.142.43.55]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 61EBB1C9DFA for ; Thu, 31 Oct 2024 15:46:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=193.142.43.55 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730389607; cv=none; b=QRBy+l0gM5z3YazT8Z/voQnhno7FO740/xjxsMPSFUKqWOREFdclYpv0os5fDxpVQ7L527epwzFmvhVJn2RITCBBYx7jJjW6cfreGL6WdKH5e+U1QZuI6pzN0bSunFVSrWY4n5t2e6SwCs2Wa7oisjmT3ooeYHuHYofBEp320hg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1730389607; c=relaxed/simple; bh=7c5QRSKQA52SKmS1EH5RYorrhCBH8qfFuGbhfocM9hk=; h=Message-ID:From:To:Cc:Subject:References:MIME-Version: Content-Type:Date; b=nx7jJRKlfNEYv7UJKcXSVtFxj5yOJseGsrD7HWEnFCw7dD7lb8gKVovQ0kFCpJmYr9dXVT6kD+aVmYMAN30XgjqOzp9v1EMzrDGK67JqhEnwHgwTUB/dPPp3foQNZl+RtboAdfv8ASAadOXKEGEo6pwMOv7KUG8UlgvlzlPzol0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de; spf=pass smtp.mailfrom=linutronix.de; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=Nb+sMgDd; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b=X9UhTArh; arc=none smtp.client-ip=193.142.43.55 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linutronix.de Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linutronix.de Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="Nb+sMgDd"; dkim=permerror (0-bit key) header.d=linutronix.de header.i=@linutronix.de header.b="X9UhTArh" Message-ID: <20241031154425.561437034@linutronix.de> DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020; t=1730389602; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: references:references; bh=5cD4EWhFiwvgt4NeHdGNlwFFc6149AA5uT1Wd9/5kEI=; b=Nb+sMgDdib7fJG0kfI1Ao+Qv+U3FJQRqaqwV9c2SEgVRzCDrQ+QzFjhiqpS12bxv4Fbkrk S2JaDejlsT8C39lKTMZWt4h/66rbePKGGQjHAujb2fGh3x6jHF4GxfGENLhgf/AdGH/9b6 MSFLlsljKnfNiMSaQZlJ5Wdd70LcKOQ2g6VHco75KXH1LHfqmyBEP2T63IsfuGXmRZn1o7 bcgcBeBh7LMB7YIz81NkPz1BW9FxpdcT2yilvC5MDu8jVuN8lJXQTHCFhYnQzLBN9E/cJJ C743g1l1x2IR7CQMmgKIQxKsUrVkqR1XfMHKgLJs0exMRTto0lBOnKwEEx6Wxw== DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=linutronix.de; s=2020e; t=1730389602; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: references:references; bh=5cD4EWhFiwvgt4NeHdGNlwFFc6149AA5uT1Wd9/5kEI=; b=X9UhTArhE/QYhFQqAi1KRvb4QN0CbMtv3aEbyaYtsEeDDgLRSbGE8B3Jmb4pvosydPCURp ff30iBD9VEY9KjCg== From: Thomas Gleixner To: LKML Cc: Anna-Maria Behnsen , Frederic Weisbecker , John Stultz , Peter Zijlstra , Ingo Molnar , Stephen Boyd , Eric Biederman , Oleg Nesterov Subject: [patch v6 16/20] signal: Handle ignored signals in do_sigaction(action != SIG_IGN) References: <20241031151625.361697424@linutronix.de> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Date: Thu, 31 Oct 2024 16:46:42 +0100 (CET) Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Thomas Gleixner When a real handler (including SIG_DFL) is installed for a signal, which had previously SIG_IGN set, then the list of ignored posix timers has to be checked for timers which are affected by this change. Add a list walk function which checks for the matching signal number and if found requeues the timers signal, so the timer is rearmed on signal delivery. Rearming the timer right away is not possible because that requires to drop sighand lock. No functional change as the counter part which queues the timers on the ignored list is still missing. Signed-off-by: Thomas Gleixner Acked-by: Peter Zijlstra (Intel) Reviewed-by: Frederic Weisbecker --- kernel/signal.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++= +- 1 file changed, 52 insertions(+), 1 deletion(-) --- --- a/kernel/signal.c +++ b/kernel/signal.c @@ -2030,7 +2030,54 @@ int posixtimer_send_sigqueue(struct k_it unlock_task_sighand(t, &flags); return ret; } -#endif /* CONFIG_POSIX_TIMERS */ + +static void posixtimer_sig_unignore(struct task_struct *tsk, int sig) +{ + struct hlist_head *head =3D &tsk->signal->ignored_posix_timers; + struct hlist_node *tmp; + struct k_itimer *tmr; + + if (likely(hlist_empty(head))) + return; + + /* + * Rearming a timer with sighand lock held is not possible due to + * lock ordering vs. tmr::it_lock. Just stick the sigqueue back and + * let the signal delivery path deal with it whether it needs to be + * rearmed or not. This cannot be decided here w/o dropping sighand + * lock and creating a loop retry horror show. + */ + hlist_for_each_entry_safe(tmr, tmp , head, ignored_list) { + struct task_struct *target; + + /* + * tmr::sigq.info.si_signo is immutable, so accessing it + * without holding tmr::it_lock is safe. + */ + if (tmr->sigq.info.si_signo !=3D sig) + continue; + + hlist_del_init(&tmr->ignored_list); + + /* This should never happen and leaks a reference count */ + if (WARN_ON_ONCE(!list_empty(&tmr->sigq.list))) + continue; + + /* + * Get the target for the signal. If target is a thread and + * has exited by now, drop the reference count. + */ + guard(rcu)(); + target =3D posixtimer_get_target(tmr); + if (target) + posixtimer_queue_sigqueue(&tmr->sigq, target, tmr->it_pid_type); + else + posixtimer_putref(tmr); + } +} +#else /* CONFIG_POSIX_TIMERS */ +static inline void posixtimer_sig_unignore(struct task_struct *tsk, int si= g) { } +#endif /* !CONFIG_POSIX_TIMERS */ =20 void do_notify_pidfd(struct task_struct *task) { @@ -4208,6 +4255,8 @@ int do_sigaction(int sig, struct k_sigac sigaction_compat_abi(act, oact); =20 if (act) { + bool was_ignored =3D k->sa.sa_handler =3D=3D SIG_IGN; + sigdelsetmask(&act->sa.sa_mask, sigmask(SIGKILL) | sigmask(SIGSTOP)); *k =3D *act; @@ -4228,6 +4277,8 @@ int do_sigaction(int sig, struct k_sigac flush_sigqueue_mask(p, &mask, &p->signal->shared_pending); for_each_thread(p, t) flush_sigqueue_mask(p, &mask, &t->pending); + } else if (was_ignored) { + posixtimer_sig_unignore(p, sig); } }