selftests/timers/posix_timers: Validate signal rules

Add a test case to validate correct behaviour vs. timer reprogramming and
deletion.

The handling of queued signals in case of timer reprogramming or deletion
is inconsistent at best.

POSIX does not really specify the behaviour for that:

 - "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.

Add tests to validate that no unexpected signals are delivered. They fail
for now until the signal and posix timer code is updated.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Frederic Weisbecker <frederic@kernel.org>

diff --git a/tools/testing/selftests/timers/posix_timers.c b/tools/testing/selftests/timers/posix_timers.c
index 8a6139a1d27aca96a8b698cb98b8decbbddbd4ac..41b43d1327eb7f0dea2331db4f03d149d8d153df 100644 (file)
--- a/tools/testing/selftests/timers/posix_timers.c
+++ b/tools/testing/selftests/timers/posix_timers.c
@@ -334,10 +334,114 @@ static void check_sig_ign(int thread)
        }
 }
 
+static void check_rearm(void)
+{
+       struct tmrsig tsig = { };
+       struct itimerspec its;
+       struct sigaction sa;
+       struct sigevent sev;
+       timer_t timerid;
+       sigset_t set;
+
+       sa.sa_flags = SA_SIGINFO;
+       sa.sa_sigaction = siginfo_handler;
+       sigemptyset(&sa.sa_mask);
+       if (sigaction(SIGUSR1, &sa, NULL))
+               fatal_error(NULL, "sigaction()");
+
+       /* Block the signal */
+       sigemptyset(&set);
+       sigaddset(&set, SIGUSR1);
+       if (sigprocmask(SIG_BLOCK, &set, NULL))
+               fatal_error(NULL, "sigprocmask(SIG_BLOCK)");
+
+       memset(&sev, 0, sizeof(sev));
+       sev.sigev_notify = SIGEV_SIGNAL;
+       sev.sigev_signo = SIGUSR1;
+       sev.sigev_value.sival_ptr = &tsig;
+       if (timer_create(CLOCK_MONOTONIC, &sev, &timerid))
+               fatal_error(NULL, "timer_create()");
+
+       /* Start the timer to expire in 100ms and 100ms intervals */
+       its.it_value.tv_sec = 0;
+       its.it_value.tv_nsec = 100000000;
+       its.it_interval.tv_sec = 0;
+       its.it_interval.tv_nsec = 100000000;
+       if (timer_settime(timerid, 0, &its, NULL))
+               fatal_error(NULL, "timer_settime()");
+
+       sleep(1);
+
+       /* Reprogram the timer to single shot */
+       its.it_value.tv_sec = 10;
+       its.it_value.tv_nsec = 0;
+       its.it_interval.tv_sec = 0;
+       its.it_interval.tv_nsec = 0;
+       if (timer_settime(timerid, 0, &its, NULL))
+               fatal_error(NULL, "timer_settime()");
+
+       /* Unblock it, which should not deliver a signal */
+       if (sigprocmask(SIG_UNBLOCK, &set, NULL))
+               fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)");
+
+       if (timer_delete(timerid))
+               fatal_error(NULL, "timer_delete()");
+
+       ksft_test_result(!tsig.signals, "check_rearm\n");
+}
+
+static void check_delete(void)
+{
+       struct tmrsig tsig = { };
+       struct itimerspec its;
+       struct sigaction sa;
+       struct sigevent sev;
+       timer_t timerid;
+       sigset_t set;
+
+       sa.sa_flags = SA_SIGINFO;
+       sa.sa_sigaction = siginfo_handler;
+       sigemptyset(&sa.sa_mask);
+       if (sigaction(SIGUSR1, &sa, NULL))
+               fatal_error(NULL, "sigaction()");
+
+       /* Block the signal */
+       sigemptyset(&set);
+       sigaddset(&set, SIGUSR1);
+       if (sigprocmask(SIG_BLOCK, &set, NULL))
+               fatal_error(NULL, "sigprocmask(SIG_BLOCK)");
+
+       memset(&sev, 0, sizeof(sev));
+       sev.sigev_notify = SIGEV_SIGNAL;
+       sev.sigev_signo = SIGUSR1;
+       sev.sigev_value.sival_ptr = &tsig;
+       if (timer_create(CLOCK_MONOTONIC, &sev, &timerid))
+               fatal_error(NULL, "timer_create()");
+
+       /* Start the timer to expire in 100ms and 100ms intervals */
+       its.it_value.tv_sec = 0;
+       its.it_value.tv_nsec = 100000000;
+       its.it_interval.tv_sec = 0;
+       its.it_interval.tv_nsec = 100000000;
+       if (timer_settime(timerid, 0, &its, NULL))
+               fatal_error(NULL, "timer_settime()");
+
+       sleep(1);
+
+       if (timer_delete(timerid))
+               fatal_error(NULL, "timer_delete()");
+
+       /* Unblock it, which should not deliver a signal */
+       if (sigprocmask(SIG_UNBLOCK, &set, NULL))
+               fatal_error(NULL, "sigprocmask(SIG_UNBLOCK)");
+
+       ksft_test_result(!tsig.signals, "check_delete\n");
+}
+
 int main(int argc, char **argv)
 {
        ksft_print_header();
-       ksft_set_plan(8);
+       ksft_set_plan(10);
 
        ksft_print_msg("Testing posix timers. False negative may happen on CPU execution \n");
        ksft_print_msg("based timers if other threads run on the CPU...\n");
@@ -361,6 +465,8 @@ int main(int argc, char **argv)
 
        check_sig_ign(0);
        check_sig_ign(1);
+       check_rearm();
+       check_delete();
 
        ksft_finished();
 }