selftests/futex: Adapt the private hash test to RCU related changes

The auto scaling on create creation used to automatically assign the new
hash because there was the private hash was unused and could be replaced
right away.

This is already racy because if the private hash is in use by a thread
then the visibile resize will be delayed. With the upcoming change to
wait for a RCU grace period before the hash can be assigned, the test
will always fail.

If the reported number of hash buckets is not updated after an
auto scaling event, block on an acquired lock with a timeout. The timeout
is the delay to wait towards a grace period and locking and a locked
pthread_mutex_t ensure that glibc calls into kernel using futex
operation which will assign new private hash if available.
This will retry every 100ms up to 2 seconds in total.

Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://lore.kernel.org/r/20250710110011.384614-2-bigeasy@linutronix.de

diff --git a/tools/testing/selftests/futex/functional/futex_priv_hash.c b/tools/testing/selftests/futex/functional/futex_priv_hash.c
index 24a92dc94eb86cc0e03ded5d6a4a0a96b0dc8a36..625e3be4129c3332f91ed7ef3fbeffd94746729b 100644 (file)
--- a/tools/testing/selftests/futex/functional/futex_priv_hash.c
+++ b/tools/testing/selftests/futex/functional/futex_priv_hash.c
@@ -111,6 +111,30 @@ static void join_max_threads(void)
        }
 }
 
+#define SEC_IN_NSEC    1000000000
+#define MSEC_IN_NSEC   1000000
+
+static void futex_dummy_op(void)
+{
+       pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+       struct timespec timeout;
+       int ret;
+
+       pthread_mutex_lock(&lock);
+       clock_gettime(CLOCK_REALTIME, &timeout);
+       timeout.tv_nsec += 100 * MSEC_IN_NSEC;
+       if (timeout.tv_nsec >=  SEC_IN_NSEC) {
+               timeout.tv_nsec -= SEC_IN_NSEC;
+               timeout.tv_sec++;
+       }
+       ret = pthread_mutex_timedlock(&lock, &timeout);
+       if (ret == 0)
+               ksft_exit_fail_msg("Succeffuly locked an already locked mutex.\n");
+
+       if (ret != ETIMEDOUT)
+               ksft_exit_fail_msg("pthread_mutex_timedlock() did not timeout: %d.\n", ret);
+}
+
 static void usage(char *prog)
 {
        printf("Usage: %s\n", prog);
@@ -129,7 +153,7 @@ int main(int argc, char *argv[])
        int futex_slots1, futex_slotsn, online_cpus;
        pthread_mutexattr_t mutex_attr_pi;
        int use_global_hash = 0;
-       int ret;
+       int ret, retry = 20;
        int c;
 
        while ((c = getopt(argc, argv, "cghv:")) != -1) {
@@ -208,8 +232,24 @@ int main(int argc, char *argv[])
         */
        ksft_print_msg("Online CPUs: %d\n", online_cpus);
        if (online_cpus > 16) {
+retry_getslots:
                futex_slotsn = futex_hash_slots_get();
                if (futex_slotsn < 0 || futex_slots1 == futex_slotsn) {
+                       retry--;
+                       /*
+                        * Auto scaling on thread creation can be slightly delayed
+                        * because it waits for a RCU grace period twice. The new
+                        * private hash is assigned upon the first futex operation
+                        * after grace period.
+                        * To cover all this for testing purposes the function
+                        * below will acquire a lock and acquire it again with a
+                        * 100ms timeout which must timeout. This ensures we
+                        * sleep for 100ms and issue a futex operation.
+                        */
+                       if (retry > 0) {
+                               futex_dummy_op();
+                               goto retry_getslots;
+                       }
                        ksft_print_msg("Expected increase of hash buckets but got: %d -> %d\n",
                                       futex_slots1, futex_slotsn);
                        ksft_exit_fail_msg(test_msg_auto_inc);