posix-timers: Make signal delivery consistent

Signals of timers which are reprogammed, disarmed or deleted can deliver
signals related to the past. The POSIX spec is blury about this:

 - "The effect of disarming or resetting a timer with pending expiration
    notifications is unspecified."

 - "The disposition of pending signals for the deleted timer is
    unspecified."

In both cases it is reasonable to expect that pending signals are
discarded. Especially in the reprogramming case it does not make sense to
account for previous overruns or to deliver a signal for a timer which has
been disarmed. This makes the behaviour consistent and understandable.

Remove the si_sys_private check from the signal delivery code and invoke
posix_timer_deliver_signal() unconditionally for posix timer related
signals.

Change posix_timer_deliver_signal() so it controls the actual signal
delivery via the return value. It now instructs the signal code to drop the
signal when:

  1) The timer does not longer exist in the hash table

  2) The timer signal_seq value is not the same as the si_sys_private value
     which was set when the signal was queued.

This is also a preparatory change to embed the sigqueue into the k_itimer
structure, which in turn allows to remove the si_sys_private magic.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lore.kernel.org/all/20241105064213.040348644@linutronix.de

diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index 02afbb4da7f783c7e527cfc116ab3bea619e39d1..8c6d97412526b07eae8e62bc06a7d3c1c3803621 100644 (file)
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -137,8 +137,6 @@ static inline void clear_posix_cputimers_work(struct task_struct *p) { }
 static inline void posix_cputimers_init_work(void) { }
 #endif
 
-#define REQUEUE_PENDING 1
-
 /**
  * struct k_itimer - POSIX.1b interval timer structure.
  * @list:              List head for binding the timer to signals->posix_timers

diff --git a/kernel/signal.c b/kernel/signal.c
index df34aa47181e6c27e64ad8d76064becf86a6c3b4..68e6bc70ccf2cfb5738e681e4b848d3c711a3276 100644 (file)
--- a/kernel/signal.c
+++ b/kernel/signal.c
@@ -550,10 +550,8 @@ still_pending:
                list_del_init(&first->list);
                copy_siginfo(info, &first->info);
 
-               *resched_timer =
-                       (first->flags & SIGQUEUE_PREALLOC) &&
-                       (info->si_code == SI_TIMER) &&
-                       (info->si_sys_private);
+               *resched_timer = (first->flags & SIGQUEUE_PREALLOC) &&
+                                (info->si_code == SI_TIMER);
 
                __sigqueue_free(first);
        } else {

diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index 5f444e3724649b11a9bd86130f250412df4cd7c5..4305c003c8d4b35e70a9dabaa7fec8613556a03e 100644 (file)
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -746,7 +746,7 @@ static void __posix_cpu_timer_get(struct k_itimer *timer, struct itimerspec64 *i
         *  - Timers which expired, but the signal has not yet been
         *    delivered
         */
-       if (iv && ((timer->it_signal_seq & REQUEUE_PENDING) || sigev_none))
+       if (iv && timer->it_status != POSIX_TIMER_ARMED)
                expires = bump_cpu_timer(timer, now);
        else
                expires = cpu_timer_getexpires(&timer->it.cpu);

diff --git a/kernel/time/posix-timers.c b/kernel/time/posix-timers.c
index dd72b8e72697a2caf9ef1d29539787e9f2c16656..b380e25d49474d674a93ba4896d7bd32021bd267 100644 (file)
--- a/kernel/time/posix-timers.c
+++ b/kernel/time/posix-timers.c
@@ -269,7 +269,10 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)
        if (!timr)
                goto out;
 
-       if (timr->it_interval && timr->it_signal_seq == info->si_sys_private) {
+       if (timr->it_signal_seq != info->si_sys_private)
+               goto out_unlock;
+
+       if (timr->it_interval && !WARN_ON_ONCE(timr->it_status != POSIX_TIMER_REQUEUE_PENDING)) {
                timr->kclock->timer_rearm(timr);
 
                timr->it_status = POSIX_TIMER_ARMED;
@@ -281,6 +284,7 @@ bool posixtimer_deliver_signal(struct kernel_siginfo *info)
        }
        ret = true;
 
+out_unlock:
        unlock_timer(timr, flags);
 out:
        spin_lock(&current->sighand->siglock);
@@ -293,19 +297,18 @@ out:
 int posix_timer_queue_signal(struct k_itimer *timr)
 {
        enum posix_timer_state state = POSIX_TIMER_DISARMED;
-       int ret, si_private = 0;
        enum pid_type type;
+       int ret;
 
        lockdep_assert_held(&timr->it_lock);
 
-       if (timr->it_interval) {
+       if (timr->it_interval)
                state = POSIX_TIMER_REQUEUE_PENDING;
-               si_private = ++timr->it_signal_seq;
-       }
+
        timr->it_status = state;
 
        type = !(timr->it_sigev_notify & SIGEV_THREAD_ID) ? PIDTYPE_TGID : PIDTYPE_PID;
-       ret = send_sigqueue(timr->sigq, timr->it_pid, type, si_private);
+       ret = send_sigqueue(timr->sigq, timr->it_pid, type, timr->it_signal_seq);
        /* If we failed to send the signal the timer stops. */
        return ret > 0;
 }
@@ -663,7 +666,7 @@ void common_timer_get(struct k_itimer *timr, struct itimerspec64 *cur_setting)
         * is a SIGEV_NONE timer move the expiry time forward by intervals,
         * so expiry is > now.
         */
-       if (iv && (timr->it_signal_seq & REQUEUE_PENDING || sig_none))
+       if (iv && timr->it_status != POSIX_TIMER_ARMED)
                timr->it_overrun += kc->timer_forward(timr, now);
 
        remaining = kc->timer_remaining(timr, now);
@@ -863,8 +866,6 @@ void posix_timer_set_common(struct k_itimer *timer, struct itimerspec64 *new_set
        else
                timer->it_interval = 0;
 
-       /* Prevent reloading in case there is a signal pending */
-       timer->it_signal_seq = (timer->it_signal_seq + 2) & ~REQUEUE_PENDING;
        /* Reset overrun accounting */
        timer->it_overrun_last = 0;
        timer->it_overrun = -1LL;
@@ -882,8 +883,6 @@ int common_timer_set(struct k_itimer *timr, int flags,
        if (old_setting)
                common_timer_get(timr, old_setting);
 
-       /* Prevent rearming by clearing the interval */
-       timr->it_interval = 0;
        /*
         * Careful here. On SMP systems the timer expiry function could be
         * active and spinning on timr->it_lock.
@@ -933,6 +932,9 @@ retry:
        if (old_spec64)
                old_spec64->it_interval = ktime_to_timespec64(timr->it_interval);
 
+       /* Prevent signal delivery and rearming. */
+       timr->it_signal_seq++;
+
        kc = timr->kclock;
        if (WARN_ON_ONCE(!kc || !kc->timer_set))
                error = -EINVAL;
@@ -1001,7 +1003,6 @@ int common_timer_del(struct k_itimer *timer)
 {
        const struct k_clock *kc = timer->kclock;
 
-       timer->it_interval = 0;
        if (kc->timer_try_to_cancel(timer) < 0)
                return TIMER_RETRY;
        timer->it_status = POSIX_TIMER_DISARMED;
@@ -1012,6 +1013,9 @@ static inline int timer_delete_hook(struct k_itimer *timer)
 {
        const struct k_clock *kc = timer->kclock;
 
+       /* Prevent signal delivery and rearming. */
+       timer->it_signal_seq++;
+
        if (WARN_ON_ONCE(!kc || !kc->timer_del))
                return -EINVAL;
        return kc->timer_del(timer);