[V7,07/19] syscalls/futex: Add support for time64 tests

This adds support for time64 tests to the existing futex() syscall
tests.

Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Reviewed-by: Petr Vorel <pvorel@suse.cz>
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
---
 .../syscalls/futex/futex_cmp_requeue01.c      |  34 +++-
 .../syscalls/futex/futex_cmp_requeue02.c      |  24 ++-
 testcases/kernel/syscalls/futex/futex_utils.h |  52 +++++--
 .../kernel/syscalls/futex/futex_wait01.c      |  79 +++++-----
 .../kernel/syscalls/futex/futex_wait02.c      | 102 ++++++------
 .../kernel/syscalls/futex/futex_wait03.c      |  87 ++++++-----
 .../kernel/syscalls/futex/futex_wait04.c      |  81 +++++-----
 .../kernel/syscalls/futex/futex_wait05.c      |   2 +-
 .../syscalls/futex/futex_wait_bitset01.c      |  48 ++++--
 .../kernel/syscalls/futex/futex_wake01.c      |  67 ++++----
 .../kernel/syscalls/futex/futex_wake02.c      |  95 ++++++------
 .../kernel/syscalls/futex/futex_wake03.c      | 109 +++++++------
 .../kernel/syscalls/futex/futex_wake04.c      | 145 +++++++++---------
 testcases/kernel/syscalls/futex/futextest.h   | 122 ++++++++++-----
 14 files changed, 580 insertions(+), 467 deletions(-)

Hi!
> Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
> Reviewed-by: Petr Vorel <pvorel@suse.cz>
> Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
> ---
>  .../syscalls/futex/futex_cmp_requeue01.c      |  34 +++-
>  .../syscalls/futex/futex_cmp_requeue02.c      |  24 ++-
>  testcases/kernel/syscalls/futex/futex_utils.h |  52 +++++--
>  .../kernel/syscalls/futex/futex_wait01.c      |  79 +++++-----
>  .../kernel/syscalls/futex/futex_wait02.c      | 102 ++++++------
>  .../kernel/syscalls/futex/futex_wait03.c      |  87 ++++++-----
>  .../kernel/syscalls/futex/futex_wait04.c      |  81 +++++-----
>  .../kernel/syscalls/futex/futex_wait05.c      |   2 +-
>  .../syscalls/futex/futex_wait_bitset01.c      |  48 ++++--
>  .../kernel/syscalls/futex/futex_wake01.c      |  67 ++++----
>  .../kernel/syscalls/futex/futex_wake02.c      |  95 ++++++------
>  .../kernel/syscalls/futex/futex_wake03.c      | 109 +++++++------
>  .../kernel/syscalls/futex/futex_wake04.c      | 145 +++++++++---------
>  testcases/kernel/syscalls/futex/futextest.h   | 122 ++++++++++-----
>  14 files changed, 580 insertions(+), 467 deletions(-)
> 
> diff --git a/testcases/kernel/syscalls/futex/futex_cmp_requeue01.c b/testcases/kernel/syscalls/futex/futex_cmp_requeue01.c
> index c50fade9f969..537641766357 100644
> --- a/testcases/kernel/syscalls/futex/futex_cmp_requeue01.c
> +++ b/testcases/kernel/syscalls/futex/futex_cmp_requeue01.c
> @@ -42,14 +42,29 @@ static struct tcase {
>  	{1000, 300, 500},
>  };
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	enum tst_ts_type tstype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .tstype = TST_KERN_OLD_TIMESPEC, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .tstype = TST_KERN_TIMESPEC, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void do_child(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
> +	struct tst_ts usec = tst_ts_from_ms(tv->tstype, max_sleep_ms);
>  	int slept_for_ms = 0;
> -	struct timespec usec = tst_timespec_from_ms(max_sleep_ms);
>  	int pid = getpid();
>  	int ret = 0;
>  
> -	if (futex_wait(&sd->futexes[0], sd->futexes[0], &usec, 0) == -1) {
> +	if (futex_wait(tv->fntype, &sd->futexes[0], sd->futexes[0], &usec, 0) == -1) {
>  		if (errno == EAGAIN) {
>  			/* spurious wakeup or signal */
>  			tst_atomic_inc(&sd->spurious);
> @@ -72,6 +87,7 @@ static void do_child(void)
>  
>  static void verify_futex_cmp_requeue(unsigned int n)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	int num_requeues = 0, num_waits = 0, num_total = 0;
>  	int i, status, spurious, woken_up;
>  	struct tcase *tc = &tcases[n];
> @@ -104,8 +120,8 @@ static void verify_futex_cmp_requeue(unsigned int n)
>  	 * specifies an upper limit on the number of waiters that are requeued.
>  	 * Returns the total number of waiters that were woken up or requeued.
>  	 */
> -	TEST(futex_cmp_requeue(&sd->futexes[0], sd->futexes[0], &sd->futexes[1],
> -		tc->set_wakes, tc->set_requeues, 0));
> +	TEST(futex_cmp_requeue(tv->fntype, &sd->futexes[0], sd->futexes[0],
> +			&sd->futexes[1], tc->set_wakes, tc->set_requeues, 0));
>  
>  	/* Fail if more than requested wakes + requeues were returned */
>  	if (TST_RET > exp_ret) {
> @@ -115,8 +131,8 @@ static void verify_futex_cmp_requeue(unsigned int n)
>  		tst_res(TINFO, "futex_cmp_requeue() returned %ld", TST_RET);
>  	}
>  
> -	num_requeues = futex_wake(&sd->futexes[1], tc->num_waiters, 0);
> -	num_waits = futex_wake(&sd->futexes[0], tc->num_waiters, 0);
> +	num_requeues = futex_wake(tv->fntype, &sd->futexes[1], tc->num_waiters, 0);
> +	num_waits = futex_wake(tv->fntype, &sd->futexes[0], tc->num_waiters, 0);
>  
>  	tst_atomic_store(1, &sd->test_done);
>  	for (i = 0; i < tc->num_waiters; i++) {
> @@ -178,6 +194,11 @@ static void verify_futex_cmp_requeue(unsigned int n)
>  
>  static void setup(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
> +
>  	max_sleep_ms = tst_multiply_timeout(5000);
>  
>  	sd = SAFE_MMAP(NULL, sizeof(*sd), PROT_READ | PROT_WRITE,
> @@ -198,5 +219,6 @@ static struct tst_test test = {
>  	.cleanup = cleanup,
>  	.tcnt = ARRAY_SIZE(tcases),
>  	.test = verify_futex_cmp_requeue,
> +	.test_variants = ARRAY_SIZE(variants),
>  	.forks_child = 1,
>  };
> diff --git a/testcases/kernel/syscalls/futex/futex_cmp_requeue02.c b/testcases/kernel/syscalls/futex/futex_cmp_requeue02.c
> index 228d8cff6ea0..dd8fafb3ee38 100644
> --- a/testcases/kernel/syscalls/futex/futex_cmp_requeue02.c
> +++ b/testcases/kernel/syscalls/futex/futex_cmp_requeue02.c
> @@ -32,12 +32,26 @@ static struct tcase {
>  	{1, 1, FUTEX_INITIALIZER + 1, EAGAIN},
>  };
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void verify_futex_cmp_requeue(unsigned int n)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	struct tcase *tc = &tcases[n];
>  
> -	TEST(futex_cmp_requeue(&futexes[0], tc->exp_val, &futexes[1],
> -	     tc->set_wakes, tc->set_requeues, 0));
> +	TEST(futex_cmp_requeue(tv->fntype, &futexes[0], tc->exp_val,
> +			&futexes[1], tc->set_wakes, tc->set_requeues, 0));
>  	if (TST_RET != -1) {
>  		tst_res(TFAIL, "futex_cmp_requeue() succeeded unexpectedly");
>  		return;
> @@ -55,6 +69,11 @@ static void verify_futex_cmp_requeue(unsigned int n)
>  
>  static void setup(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
> +
>  	futexes = SAFE_MMAP(NULL, sizeof(futex_t) * 2, PROT_READ | PROT_WRITE,
>  			    MAP_ANONYMOUS | MAP_SHARED, -1, 0);
>  
> @@ -73,6 +92,7 @@ static struct tst_test test = {
>  	.cleanup = cleanup,
>  	.test = verify_futex_cmp_requeue,
>  	.tcnt = ARRAY_SIZE(tcases),
> +	.test_variants = ARRAY_SIZE(variants),
>  	.tags = (const struct tst_tag[]) {
>  		{"CVE", "2018-6927"},
>  		{"linux-git", "fbe0e839d1e2"},
> diff --git a/testcases/kernel/syscalls/futex/futex_utils.h b/testcases/kernel/syscalls/futex/futex_utils.h
> index 63b97c00b631..f77b9d6b3b8a 100644
> --- a/testcases/kernel/syscalls/futex/futex_utils.h
> +++ b/testcases/kernel/syscalls/futex/futex_utils.h
> @@ -20,10 +20,13 @@
>  #ifndef FUTEX_UTILS_H__
>  #define FUTEX_UTILS_H__
>  
> +#include <stdio.h>
> +#include <stdlib.h>
> +
>  /*
>   * Wait for nr_threads to be sleeping
>   */
> -static int wait_for_threads(unsigned int nr_threads)
> +static inline int wait_for_threads(unsigned int nr_threads)
>  {
>  	char thread_state, name[1024];
>  	DIR *dir;
> @@ -32,34 +35,63 @@ static int wait_for_threads(unsigned int nr_threads)
>  
>  	snprintf(name, sizeof(name), "/proc/%i/task/", getpid());
>  
> -	dir = SAFE_OPENDIR(NULL, name);
> +	dir = SAFE_OPENDIR(name);
>  
> -	while ((dent = SAFE_READDIR(NULL, dir))) {
> +	while ((dent = SAFE_READDIR(dir))) {
>  		/* skip ".", ".." and the main thread */
>  		if (atoi(dent->d_name) == getpid() || atoi(dent->d_name) == 0)
>  			continue;
>  
>  		snprintf(name, sizeof(name), "/proc/%i/task/%s/stat",
> -		         getpid(), dent->d_name);
> +			 getpid(), dent->d_name);
>  
> -		SAFE_FILE_SCANF(NULL, name, "%*i %*s %c", &thread_state);
> +		SAFE_FILE_SCANF(name, "%*i %*s %c", &thread_state);
>  
>  		if (thread_state != 'S') {
> -			tst_resm(TINFO, "Thread %s not sleeping yet", dent->d_name);
> -			SAFE_CLOSEDIR(NULL, dir);
> +			tst_res(TINFO, "Thread %s not sleeping yet", dent->d_name);
> +			SAFE_CLOSEDIR(dir);
>  			return 1;
>  		}
>  		cnt++;
>  	}
>  
> -	SAFE_CLOSEDIR(NULL, dir);
> +	SAFE_CLOSEDIR(dir);
>  
>  	if (cnt != nr_threads) {
> -		tst_resm(TINFO, "%u threads sleeping, expected %u",
> -	                  cnt, nr_threads);
> +		tst_res(TINFO, "%u threads sleeping, expected %u", cnt,
> +			nr_threads);
>  	}
>  
>  	return 0;
>  }
>  
> +static inline int process_state_wait2(pid_t pid, const char state)
> +{
> +	char proc_path[128], cur_state;
> +
> +	snprintf(proc_path, sizeof(proc_path), "/proc/%i/stat", pid);
> +
> +	for (;;) {
> +		FILE *f = fopen(proc_path, "r");
> +		if (!f) {
> +			tst_res(TFAIL, "Failed to open '%s': %s\n", proc_path,
> +				strerror(errno));
> +			return 1;
> +		}
> +
> +		if (fscanf(f, "%*i %*s %c", &cur_state) != 1) {
> +			fclose(f);
> +			tst_res(TFAIL, "Failed to read '%s': %s\n", proc_path,
> +				strerror(errno));
> +			return 1;
> +		}
> +		fclose(f);
> +
> +		if (state == cur_state)
> +			return 0;
> +
> +		usleep(10000);
> +	}
> +}

There is no reason not to use the TST_PROCESS_STATE_WAIT() in the new
API tests. The old API was broken in child processes hence the special
function for children.

>  #endif /* FUTEX_UTILS_H__ */
> diff --git a/testcases/kernel/syscalls/futex/futex_wait01.c b/testcases/kernel/syscalls/futex/futex_wait01.c
> index 51a540d9e315..e884e696ef55 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait01.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait01.c
> @@ -1,3 +1,4 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> @@ -5,34 +6,15 @@
>   * written by Darren Hart <dvhltc@us.ibm.com>
>   *            Gowrishankar <gowrishankar.m@in.ibm.com>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * 1. Block on a futex and wait for timeout.
> + * 2. Test if FUTEX_WAIT op returns -EWOULDBLOCK if the futex value differs
> + *    from the expected one.
>   */
> - /*
> -  * 1. Block on a futex and wait for timeout.
> -  * 2. Test if FUTEX_WAIT op returns -EWOULDBLOCK if the futex value differs
> -  *    from the expected one.
> -  */
>  
>  #include <errno.h>
>  
> -#include "test.h"
>  #include "futextest.h"
>  
> -const char *TCID="futex_wait01";
> -
>  struct testcase {
>  	futex_t *f_addr;
>  	futex_t f_val;
> @@ -41,7 +23,6 @@ struct testcase {
>  };
>  
>  static futex_t futex = FUTEX_INITIALIZER;
> -static struct timespec to = {.tv_sec = 0, .tv_nsec = 10000};
>  
>  static struct testcase testcases[] = {
>  	{&futex, FUTEX_INITIALIZER, 0, ETIMEDOUT},
> @@ -50,38 +31,58 @@ static struct testcase testcases[] = {
>  	{&futex, FUTEX_INITIALIZER+1, FUTEX_PRIVATE_FLAG, EWOULDBLOCK},
>  };
>  
> -const int TST_TOTAL=ARRAY_SIZE(testcases);
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	enum tst_ts_type tstype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .tstype = TST_KERN_OLD_TIMESPEC, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .tstype = TST_KERN_TIMESPEC, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
>  
> -static void verify_futex_wait(struct testcase *tc)
> +static void run(unsigned int n)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
> +	struct testcase *tc = &testcases[n];
> +	static struct tst_ts to;

Why the static here?

>  	int res;
>  
> -	res = futex_wait(tc->f_addr, tc->f_val, &to, tc->opflags);
> +	to.type = tv->tstype;
> +	tst_ts_set_sec(&to, 0);
> +	tst_ts_set_nsec(&to, 10000);

Maybe it would be easier to write it as:

struct tst_ts to = tst_ts_from_ns(tv->ts_type, 10000);

> +	res = futex_wait(tv->fntype, tc->f_addr, tc->f_val, &to, tc->opflags);
>  
>  	if (res != -1) {
> -		tst_resm(TFAIL, "futex_wait() returned %i, expected -1", res);
> +		tst_res(TFAIL, "futex_wait() succeeded unexpectedly");
>  		return;
>  	}
>  
>  	if (errno != tc->exp_errno) {
> -		tst_resm(TFAIL | TERRNO, "expected errno=%s",
> +		tst_res(TFAIL | TTERRNO, "futex_wait() failed with incorrect error, expected errno=%s",
>  		         tst_strerrno(tc->exp_errno));
>  		return;
>  	}
>  
> -	tst_resm(TPASS | TERRNO, "futex_wait()");
> +	tst_res(TPASS | TERRNO, "futex_wait() passed");
>  }
>  
> -int main(int argc, char *argv[])
> +static void setup(void)
>  {
> -	int lc, i;
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
> -		for (i = 0; i < TST_TOTAL; i++)
> -			verify_futex_wait(testcases + i);
> -	}
> -
> -	tst_exit();
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test = run,
> +	.tcnt = ARRAY_SIZE(testcases),
> +	.test_variants = ARRAY_SIZE(variants),
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wait02.c b/testcases/kernel/syscalls/futex/futex_wait02.c
> index 1ca1df457b4a..34b78357f6e6 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait02.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait02.c
> @@ -1,105 +1,93 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> + * Block on a futex and wait for wakeup.
>   *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * This tests uses shared memory page to store the mutex variable.
>   */
> - /*
> -  * Block on a futex and wait for wakeup.
> -  *
> -  * This tests uses shared memory page to store the mutex variable.
> -  */
>  
>  #include <sys/mman.h>
>  #include <sys/wait.h>
>  #include <errno.h>
>  
> -#include "test.h"
> -#include "safe_macros.h"
>  #include "futextest.h"
> -
> -const char *TCID="futex_wait02";
> -const int TST_TOTAL=1;
> +#include "futex_utils.h"
>  
>  static futex_t *futex;
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void do_child(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	int ret;
>  
> -	tst_process_state_wait2(getppid(), 'S');
> +	process_state_wait2(getppid(), 'S');
>  
> -	ret = futex_wake(futex, 1, 0);
> +	ret = futex_wake(tv->fntype, futex, 1, 0);
>  
>  	if (ret != 1)
> -		tst_brkm(TFAIL, NULL, "futex_wake() returned %i", ret);
> +		tst_res(TFAIL | TTERRNO, "futex_wake() failed");
>  
> -	exit(TPASS);
> +	exit(0);
>  }
>  
> -static void verify_futex_wait(void)
> +static void run(void)
>  {
> -	int res;
> -	int pid;
> +	struct test_variants *tv = &variants[tst_variant];
> +	int res, pid;
>  
> -	pid = tst_fork();
> +	pid = SAFE_FORK();
>  
>  	switch (pid) {
>  	case 0:
>  		do_child();
> -	break;
> -	case -1:
> -		tst_brkm(TBROK | TERRNO, NULL, "fork() failed");
> -	break;
>  	default:
> -	break;
> +		break;
>  	}

Well we no longer have to check for the failure so maybe simple

if (!pid)
	do_child();

would suffice here.

> -	res = futex_wait(futex, *futex, NULL, 0);
> -
> +	res = futex_wait(tv->fntype, futex, *futex, NULL, 0);
>  	if (res) {
> -		tst_resm(TFAIL, "futex_wait() returned %i, errno %s",
> -		         res, tst_strerrno(errno));
> +		tst_res(TFAIL | TTERRNO, "futex_wait() failed");
> +		return;
>  	}
>  
> -	SAFE_WAIT(NULL, &res);
> +	SAFE_WAIT(&res);
>  
>  	if (WIFEXITED(res) && WEXITSTATUS(res) == TPASS)
> -		tst_resm(TPASS, "futex_wait() woken up");
> +		tst_res(TPASS, "futex_wait() woken up");
>  	else
> -		tst_resm(TFAIL, "child failed");
> +		tst_res(TFAIL, "child failed");

And we no longer have to propagate the test status like that, we can
print PASS/FAIL in the child.

>  }
>  
>  static void setup(void)
>  {
> -	futex = SAFE_MMAP(NULL, NULL, sizeof(*futex), PROT_READ | PROT_WRITE,
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
> +
> +	futex = SAFE_MMAP(NULL, sizeof(*futex), PROT_READ | PROT_WRITE,
>  			  MAP_ANONYMOUS | MAP_SHARED, -1, 0);
>  
>  	*futex = FUTEX_INITIALIZER;
>  }
>  
> -int main(int argc, char *argv[])
> -{
> -	int lc;
> -
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	setup();
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		verify_futex_wait();
> -
> -	tst_exit();
> -}
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +	.forks_child = 1,
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wait03.c b/testcases/kernel/syscalls/futex/futex_wait03.c
> index 9683e76503c0..e436b238a165 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait03.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait03.c
> @@ -1,87 +1,86 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> + * Block on a futex and wait for wakeup.
>   *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * This tests uses private mutexes with threads.
>   */
> - /*
> -  * Block on a futex and wait for wakeup.
> -  *
> -  * This tests uses private mutexes with threads.
> -  */
>  
>  #include <errno.h>
>  #include <pthread.h>
>  
> -#include "test.h"
>  #include "futextest.h"
> -
> -const char *TCID="futex_wait03";
> -const int TST_TOTAL=1;
> +#include "futex_utils.h"
>  
>  static futex_t futex = FUTEX_INITIALIZER;
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void *threaded(void *arg LTP_ATTRIBUTE_UNUSED)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	long ret;
>  
> -	tst_process_state_wait2(getpid(), 'S');
> +	process_state_wait2(getpid(), 'S');
>  
> -	ret = futex_wake(&futex, 1, FUTEX_PRIVATE_FLAG);
> +	ret = futex_wake(tv->fntype, &futex, 1, FUTEX_PRIVATE_FLAG);
>  
>  	return (void*)ret;
>  }
>  
> -static void verify_futex_wait(void)
> +static void run(void)
>  {
> -	long ret;
> -	int res;
> +	struct test_variants *tv = &variants[tst_variant];
> +	long ret, res;
>  	pthread_t t;
>  
>  	res = pthread_create(&t, NULL, threaded, NULL);
>  	if (res) {
> -		tst_brkm(TBROK, NULL, "pthread_create(): %s",
> -	                 tst_strerrno(res));
> +		tst_res(TFAIL | TTERRNO, "pthread_create() failed");
> +		return;
>  	}

Thread functions does not set errno, they return the error instead.

Also we do have tst_safe_pthread.h for new library testcases.

> -	res = futex_wait(&futex, futex, NULL, FUTEX_PRIVATE_FLAG);
> +	res = futex_wait(tv->fntype, &futex, futex, NULL, FUTEX_PRIVATE_FLAG);
>  	if (res) {
> -		tst_resm(TFAIL, "futex_wait() returned %i, errno %s",
> -	                 res, tst_strerrno(errno));
> +		tst_res(TFAIL | TTERRNO, "futex_wait() failed");

Beware that the TTERRNO is not TERRNO. The TERRNO uses errno to print
the error while TTERRNO uses TST_ERR, so it does not make sense to use
TTERRNO if you aren't using TEST() macro.

>  		pthread_join(t, NULL);
>  		return;
>  	}
>  
>  	res = pthread_join(t, (void*)&ret);
> -	if (res)
> -		tst_brkm(TBROK, NULL, "pthread_join(): %s", tst_strerrno(res));
> +	if (res) {
> +		tst_res(TFAIL | TTERRNO, "pthread_join() failed");
> +		return;
> +	}

Here as well, pthreads functions.

>  	if (ret != 1)
> -		tst_resm(TFAIL, "futex_wake() returned %li", ret);
> +		tst_res(TFAIL, "futex_wake() returned %li", ret);
>  	else
> -		tst_resm(TPASS, "futex_wait() woken up");
> +		tst_res(TPASS, "futex_wait() woken up");

The new test library is thread safe as well, so we can print these
statements from the threaded function instead.

>  }
>  
> -int main(int argc, char *argv[])
> +static void setup(void)
>  {
> -	int lc;
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		verify_futex_wait();
> -
> -	tst_exit();
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wait04.c b/testcases/kernel/syscalls/futex/futex_wait04.c
> index b8360ff80914..8de3c90b08d3 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait04.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait04.c
> @@ -1,65 +1,66 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
>   * Based on futextest (futext_wait_uninitialized_heap.c)
>   * written by KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * Wait on uninitialized heap. It shold be zero and FUTEX_WAIT should return
> + * immediately. This test tests zero page handling in futex code.
>   */
> - /*
> -  * Wait on uninitialized heap. It shold be zero and FUTEX_WAIT should return
> -  * immediately. This test tests zero page handling in futex code.
> -  */
>  
>  #include <errno.h>
>  
> -#include "test.h"
> -#include "safe_macros.h"
>  #include "futextest.h"
>  
> -const char *TCID="futex_wait04";
> -const int TST_TOTAL=1;
> -static struct timespec to = {.tv_sec = 0, .tv_nsec = 10000};
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	enum tst_ts_type tstype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .tstype = TST_KERN_OLD_TIMESPEC, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .tstype = TST_KERN_TIMESPEC, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
>  
> -static void verify_futex_wait(void)
> +static void run(void)
>  {
> -	int res;
> -	void *buf;
> +	struct test_variants *tv = &variants[tst_variant];
> +	static struct tst_ts to;
>  	size_t pagesize = getpagesize();
> -	buf = SAFE_MMAP(NULL, NULL, pagesize, PROT_READ|PROT_WRITE,
> -                        MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
> +	void *buf;
> +	int res;
> +
> +	buf = SAFE_MMAP(NULL, pagesize, PROT_READ|PROT_WRITE,
> +			MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
>  
> -	res = futex_wait(buf, 1, &to, 0);
> +	to.type = tv->tstype;
> +	tst_ts_set_sec(&to, 0);
> +	tst_ts_set_nsec(&to, 10000);

Here as well.

> +	res = futex_wait(tv->fntype, buf, 1, &to, 0);
>  	if (res == -1 && errno == EWOULDBLOCK)
> -		tst_resm(TPASS | TERRNO, "futex_wait() returned %i", res);
> +		tst_res(TPASS | TERRNO, "futex_wait() returned %i", res);
>  	else
> -		tst_resm(TFAIL | TERRNO, "futex_wait() returned %i", res);
> +		tst_res(TFAIL | TERRNO, "futex_wait() returned %i", res);
>  
> -	SAFE_MUNMAP(NULL, buf, pagesize);
> +	SAFE_MUNMAP(buf, pagesize);
>  }
>  
> -int main(int argc, char *argv[])
> +static void setup(void)
>  {
> -	int lc;
> -
> -	tst_parse_opts(argc, argv, NULL, NULL);
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		verify_futex_wait();
> -
> -	tst_exit();
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wait05.c b/testcases/kernel/syscalls/futex/futex_wait05.c
> index 2573ae177d5b..8fad5d858716 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait05.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait05.c
> @@ -19,7 +19,7 @@ int sample_fn(int clk_id, long long usec)
>  	futex_t futex = FUTEX_INITIALIZER;
>  
>  	tst_timer_start(clk_id);
> -	TEST(futex_wait(&futex, futex, &to, 0));
> +	TEST(syscall(SYS_futex, &futex, FUTEX_WAIT, futex, &to, NULL, 0));
>  	tst_timer_stop();
>  	tst_timer_sample();

Why aren't we adding the two functions here as well?

Is the timer library incompatible with test variants?

> diff --git a/testcases/kernel/syscalls/futex/futex_wait_bitset01.c b/testcases/kernel/syscalls/futex/futex_wait_bitset01.c
> index b8546c3e640c..a871af992572 100644
> --- a/testcases/kernel/syscalls/futex/futex_wait_bitset01.c
> +++ b/testcases/kernel/syscalls/futex/futex_wait_bitset01.c
> @@ -23,22 +23,40 @@ static struct test_case_t {
>  	{ CLOCK_REALTIME }
>  };
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	enum tst_ts_type tstype;
> +	int (*gettime)(clockid_t clk_id, void *ts);
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .tstype = TST_KERN_OLD_TIMESPEC, .gettime = sys_clock_gettime, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .tstype = TST_KERN_TIMESPEC, .gettime = sys_clock_gettime64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void verify_futex_wait_bitset(long long wait_us, clock_t clk_id)
>  {
> -	struct timespec start, to, end;
> +	struct test_variants *tv = &variants[tst_variant];
> +	struct tst_ts start, to, end;
>  	futex_t futex = FUTEX_INITIALIZER;
>  	u_int32_t bitset = 0xffffffff;
>  	int flags = clk_id == CLOCK_REALTIME ? FUTEX_CLOCK_REALTIME : 0;
>  
> +	start.type = end.type = to.type = tv->tstype;
> +
>  	tst_res(TINFO, "testing futex_wait_bitset() timeout with %s",
>  		clk_id == CLOCK_REALTIME ? "CLOCK_REALTIME" : "CLOCK_MONOTONIC");
>  
> -	clock_gettime(clk_id, &start);
> -	to = tst_timespec_add_us(start, wait_us);
> +	tv->gettime(clk_id, tst_ts_get(&start));
> +	to = tst_ts_add_us(start, wait_us);
>  
> -	TEST(futex_wait_bitset(&futex, futex, &to, bitset, flags));
> +	TEST(futex_wait_bitset(tv->fntype, &futex, futex, &to, bitset, flags));
>  
> -	clock_gettime(clk_id, &end);
> +	tv->gettime(clk_id, tst_ts_get(&end));
>  
>  	if (TST_RET != -1) {
>  		tst_res(TFAIL, "futex_wait_bitset() returned %li, expected -1",
> @@ -58,22 +76,22 @@ static void verify_futex_wait_bitset(long long wait_us, clock_t clk_id)
>  		return;
>  	}
>  
> -	if (tst_timespec_lt(end, to)) {
> +	if (tst_ts_lt(end, to)) {
>  		tst_res(TFAIL,
>  			"futex_wait_bitset() woken up prematurely %llius, expected %llius",
> -			tst_timespec_diff_us(end, start), wait_us);
> +			tst_ts_diff_us(end, start), wait_us);
>  		return;
>  	}
>  
> -	if (tst_timespec_diff_us(end, to) > THRESHOLD_US) {
> +	if (tst_ts_diff_us(end, to) > THRESHOLD_US) {
>  		tst_res(TFAIL,
>  			"futex_wait_bitset() waited too long %llius, expected %llius",
> -			tst_timespec_diff_us(end, start), wait_us);
> +			tst_ts_diff_us(end, start), wait_us);
>  		return;
>  	}
>  
>  	tst_res(TPASS, "futex_wait_bitset() waited %llius, expected %llius",
> -		tst_timespec_diff_us(end, start), wait_us);
> +		tst_ts_diff_us(end, start), wait_us);
>  }
>  
>  static void run(unsigned int n)
> @@ -82,7 +100,17 @@ static void run(unsigned int n)
>  	verify_futex_wait_bitset(DEFAULT_TIMEOUT_US, tcases[n].clk_id);
>  }
>  
> +static void setup(void)
> +{
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
> +}
> +
>  static struct tst_test test = {
> +	.setup = setup,
>  	.test = run,
>  	.tcnt = ARRAY_SIZE(tcases),
> +	.test_variants = ARRAY_SIZE(variants),
>  };
> diff --git a/testcases/kernel/syscalls/futex/futex_wake01.c b/testcases/kernel/syscalls/futex/futex_wake01.c
> index 42ea6f6e6a75..2dbe8cc2f3aa 100644
> --- a/testcases/kernel/syscalls/futex/futex_wake01.c
> +++ b/testcases/kernel/syscalls/futex/futex_wake01.c
> @@ -1,33 +1,15 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * futex_wake() returns 0 (0 woken up processes) when no processes wait on the mutex.
>   */
> - /*
> -  * futex_wake() returns 0 (0 woken up processes) when no processes wait on the mutex.
> -  */
>  
>  #include <errno.h>
>  #include <limits.h>
>  
> -#include "test.h"
>  #include "futextest.h"
>  
> -const char *TCID="futex_wake01";
> -
>  struct testcase {
>  	futex_t *f_addr;
>  	int nr_wake;
> @@ -46,32 +28,45 @@ static struct testcase testcases[] = {
>  	{&futex, INT_MAX, FUTEX_PRIVATE_FLAG},
>  };
>  
> -const int TST_TOTAL=ARRAY_SIZE(testcases);
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
>  
> -static void verify_futex_wake(struct testcase *tc)
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
> +static void run(unsigned int n)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
> +	struct testcase *tc = &testcases[n];
>  	int res;
>  
> -	res = futex_wake(tc->f_addr, tc->nr_wake, tc->opflags);
> -
> +	res = futex_wake(tv->fntype, tc->f_addr, tc->nr_wake, tc->opflags);
>  	if (res != 0) {
> -		tst_resm(TFAIL, "futex_wake() returned %i, expected 0", res);
> +		tst_res(TFAIL | TTERRNO, "futex_wake() failed");

Here as well TERRNO not TTERRNO and I guess I missed a few.

>  		return;
>  	}
>  
> -	tst_resm(TPASS, "futex_wake() returned 0");
> +	tst_res(TPASS, "futex_wake() passed");
>  }
>  
> -int main(int argc, char *argv[])
> +static void setup(void)
>  {
> -	int lc, i;
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++) {
> -		for (i = 0; i < TST_TOTAL; i++)
> -			verify_futex_wake(testcases + i);
> -	}
> -
> -	tst_exit();
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test = run,
> +	.tcnt = ARRAY_SIZE(testcases),
> +	.test_variants = ARRAY_SIZE(variants),
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wake02.c b/testcases/kernel/syscalls/futex/futex_wake02.c
> index 8a4c2d58e4b9..3491839872ac 100644
> --- a/testcases/kernel/syscalls/futex/futex_wake02.c
> +++ b/testcases/kernel/syscalls/futex/futex_wake02.c
> @@ -1,40 +1,34 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * Block several threads on a private mutex, then wake them up.
>   */
> - /*
> -  * Block several threads on a private mutex, then wake them up.
> -  */
>  
>  #include <errno.h>
>  #include <pthread.h>
> +#include <sys/types.h>
>  
> -#include "test.h"
> -#include "safe_macros.h"
>  #include "futextest.h"
>  #include "futex_utils.h"
>  
> -const char *TCID="futex_wake02";
> -const int TST_TOTAL=11;
> -
>  static futex_t futex = FUTEX_INITIALIZER;
>  
>  static volatile int threads_flags[55];
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static int threads_awake(void)
>  {
>  	int ret = 0;
> @@ -58,9 +52,10 @@ static void clear_threads_awake(void)
>  
>  static void *threaded(void *arg)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	long i = (long)arg;
>  
> -	futex_wait(&futex, futex, NULL, FUTEX_PRIVATE_FLAG);
> +	futex_wait(tv->fntype, &futex, futex, NULL, FUTEX_PRIVATE_FLAG);
>  
>  	threads_flags[i] = 1;
>  
> @@ -69,14 +64,15 @@ static void *threaded(void *arg)
>  
>  static void do_child(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	int res, i, j, awake;
>  	pthread_t t[55];
>  
>  	for (i = 0; i < (int)ARRAY_SIZE(t); i++) {
>  		res = pthread_create(&t[i], NULL, threaded, (void*)((long)i));
>  		if (res) {
> -			tst_brkm(TBROK, NULL, "pthread_create(): %s",
> -			         tst_strerrno(res));
> +			tst_res(TFAIL | TTERRNO, "pthread_create() failed");
> +			return;

Here as well, the res contains the error and we do have SAFE_PTHREAD_...

>  		}
>  	}
>  
> @@ -85,9 +81,9 @@ static void do_child(void)
>  
>  	for (i = 1; i <= 10; i++) {
>  		clear_threads_awake();
> -		res = futex_wake(&futex, i, FUTEX_PRIVATE_FLAG);
> +		res = futex_wake(tv->fntype, &futex, i, FUTEX_PRIVATE_FLAG);
>  		if (i != res) {
> -			tst_resm(TFAIL,
> +			tst_res(TFAIL | TTERRNO,
>  			         "futex_wake() woken up %i threads, expected %i",
>  			         res, i);
>  		}
> @@ -101,26 +97,26 @@ static void do_child(void)
>  		}
>  
>  		if (awake == i) {
> -			tst_resm(TPASS, "futex_wake() woken up %i threads", i);
> +			tst_res(TPASS, "futex_wake() woken up %i threads", i);
>  		} else {
> -			tst_resm(TFAIL, "Woken up %i threads, expected %i",
> -			         awake, i);
> +			tst_res(TFAIL | TTERRNO, "Woken up %i threads, expected %i",
> +				awake, i);
>  		}
>  	}
>  
> -	res = futex_wake(&futex, 1, FUTEX_PRIVATE_FLAG);
> +	res = futex_wake(tv->fntype, &futex, 1, FUTEX_PRIVATE_FLAG);
>  
>  	if (res) {
> -		tst_resm(TFAIL, "futex_wake() woken up %i, none were waiting",
> -		         res);
> +		tst_res(TFAIL | TTERRNO, "futex_wake() woken up %i, none were waiting",
> +			res);
>  	} else {
> -		tst_resm(TPASS, "futex_wake() woken up 0 threads");
> +		tst_res(TPASS, "futex_wake() woken up 0 threads");
>  	}
>  
>  	for (i = 0; i < (int)ARRAY_SIZE(t); i++)
>  		pthread_join(t[i], NULL);
>  
> -	tst_exit();
> +	exit(0);
>  }
>  
>  /*
> @@ -135,30 +131,31 @@ static void do_child(void)
>   * under /proc/$PID/tasks/, but the subsequent open() fails with ENOENT because
>   * the thread was removed meanwhile.
>   */
> -static void verify_futex_wake(void)
> +static void run(void)
>  {
> -	int pid;
> +	int status, pid;
>  
> -	pid = tst_fork();
> +	pid = SAFE_FORK();
>  
>  	switch (pid) {
>  	case 0:
>  		do_child();
> -	case -1:
> -		tst_brkm(TBROK | TERRNO, NULL, "fork() failed");
>  	default:
> -		tst_record_childstatus(NULL, pid);
> +		SAFE_WAITPID(pid, &status, 0);
>  	}

Here as well no need for the switch () simple iff would suffice.

>  }
>  
> -int main(int argc, char *argv[])
> +static void setup(void)
>  {
> -	int lc;
> -
> -	tst_parse_opts(argc, argv, NULL, NULL);
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		verify_futex_wake();
> -
> -	tst_exit();
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +	.forks_child = 1,
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wake03.c b/testcases/kernel/syscalls/futex/futex_wake03.c
> index d6e5e5422db9..29e586c40132 100644
> --- a/testcases/kernel/syscalls/futex/futex_wake03.c
> +++ b/testcases/kernel/syscalls/futex/futex_wake03.c
> @@ -1,54 +1,51 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015 Cyril Hrubis <chrubis@suse.cz>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + * Block several processes on a mutex, then wake them up.
>   */
> - /*
> -  * Block several processes on a mutex, then wake them up.
> -  */
>  
>  #include <errno.h>
>  #include <sys/types.h>
>  #include <sys/wait.h>
>  
> -#include "test.h"
> -#include "safe_macros.h"
>  #include "futextest.h"
> -
> -const char *TCID="futex_wake03";
> -const int TST_TOTAL=11;
> +#include "futex_utils.h"
>  
>  static futex_t *futex;
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void do_child(void)
>  {
> -	futex_wait(futex, *futex, NULL, 0);
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	futex_wait(tv->fntype, futex, *futex, NULL, 0);
>  	exit(0);
>  }
>  
>  static void do_wake(int nr_children)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	int res, i, cnt;
>  
> -	res = futex_wake(futex, nr_children, 0);
> +	res = futex_wake(tv->fntype, futex, nr_children, 0);
>  
>  	if (res != nr_children) {
> -		tst_resm(TFAIL,
> -		         "futex_wake() woken up %i children, expected %i",
> -		         res, nr_children);
> +		tst_res(TFAIL | TTERRNO,
> +		        "futex_wake() woken up %i children, expected %i",
> +			res, nr_children);

Does anything set the TST_ERR here?

I doubt that we will even get something in errno here.

>  		return;
>  	}
>  
> @@ -63,65 +60,63 @@ static void do_wake(int nr_children)
>  	}
>  
>  	if (cnt != nr_children) {
> -		tst_resm(TFAIL, "reaped only %i childs, expected %i",
> -		         cnt, nr_children);
> +		tst_res(TFAIL | TTERRNO, "reaped only %i childs, expected %i",
> +		        cnt, nr_children);

Here as well.

>  	} else {
> -		tst_resm(TPASS, "futex_wake() woken up %i childs", cnt);
> +		tst_res(TPASS, "futex_wake() woken up %i childs", cnt);
>  	}
>  }
>  
> -static void verify_futex_wake(void)
> +static void run(void)
>  {
> -	int i, res;
> +	struct test_variants *tv = &variants[tst_variant];
>  	pid_t pids[55];
> +	unsigned int i;
> +	int res;
>  
> -	for (i = 0; i < (int)ARRAY_SIZE(pids); i++) {
> -		pids[i] = tst_fork();
> +	for (i = 0; i < ARRAY_SIZE(pids); i++) {
> +		pids[i] = SAFE_FORK();
>  
>  		switch (pids[i]) {
> -		case -1:
> -			tst_brkm(TBROK | TERRNO, NULL, "fork()");
>  		case 0:
>  			do_child();
>  		default:
> -		break;
> +			break;
>  		}

Here as well no need for the switch anymore.

>  	}
>  
> -	for (i = 0; i < (int)ARRAY_SIZE(pids); i++)
> -		tst_process_state_wait2(pids[i], 'S');
> +	for (i = 0; i < ARRAY_SIZE(pids); i++)
> +		process_state_wait2(pids[i], 'S');
>  
>  	for (i = 1; i <= 10; i++)
>  		do_wake(i);
>  
> -	res = futex_wake(futex, 1, 0);
> +	res = futex_wake(tv->fntype, futex, 1, 0);
>  
>  	if (res) {
> -		tst_resm(TFAIL, "futex_wake() woken up %u, none were waiting",
> -		         res);
> +		tst_res(TFAIL | TTERRNO, "futex_wake() woken up %u, none were waiting",
> +			res);

Here as well no real reason to add the TTERRNO.

>  	} else {
> -		tst_resm(TPASS, "futex_wake() woken up 0 children");
> +		tst_res(TPASS, "futex_wake() woken up 0 children");
>  	}
>  }
>  
>  static void setup(void)
>  {
> -	futex = SAFE_MMAP(NULL, NULL, sizeof(*futex), PROT_READ | PROT_WRITE,
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
> +
> +	futex = SAFE_MMAP(NULL, sizeof(*futex), PROT_READ | PROT_WRITE,
>  			  MAP_ANONYMOUS | MAP_SHARED, -1, 0);
>  
>  	*futex = FUTEX_INITIALIZER;
>  }
>  
> -int main(int argc, char *argv[])
> -{
> -	int lc;
> -
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	setup();
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		verify_futex_wake();
> -
> -	tst_exit();
> -}
> +static struct tst_test test = {
> +	.setup = setup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +	.forks_child = 1,
> +};
> diff --git a/testcases/kernel/syscalls/futex/futex_wake04.c b/testcases/kernel/syscalls/futex/futex_wake04.c
> index f92bda53f6c7..582ebc4b917a 100644
> --- a/testcases/kernel/syscalls/futex/futex_wake04.c
> +++ b/testcases/kernel/syscalls/futex/futex_wake04.c
> @@ -1,23 +1,9 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
>  /*
>   * Copyright (C) 2015  Yi Zhang <wetpzy@gmail.com>
>   *                     Li Wang <liwang@redhat.com>
>   *
> - * Licensed under the GNU GPLv2 or later.
> - * This program is free software;  you can redistribute it and/or modify
> - * it under the terms of the GNU General Public License as published by
> - * the Free Software Foundation; either version 2 of the License, or
> - * (at your option) any later version.
> - *
> - * This program is distributed in the hope that it will be useful,
> - * but WITHOUT ANY WARRANTY;  without even the implied warranty of
> - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
> - * the GNU General Public License for more details.
> - *
> - * You should have received a copy of the GNU General Public License
> - * along with this program;  if not, write to the Free Software
> - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> - */
> - /* DESCRIPTION:
> + * DESCRIPTION:
>   *
>   *   It is a regression test for commit:
>   *   http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/
> @@ -42,53 +28,59 @@
>  #include <sys/time.h>
>  #include <string.h>
>  
> -#include "test.h"
> -#include "safe_macros.h"
>  #include "futextest.h"
>  #include "futex_utils.h"
>  #include "lapi/mmap.h"
> +#include "tst_safe_stdio.h"
>  
>  #define PATH_MEMINFO "/proc/meminfo"
>  #define PATH_NR_HUGEPAGES "/proc/sys/vm/nr_hugepages"
>  #define PATH_HUGEPAGES	"/sys/kernel/mm/hugepages/"
>  
> -const char *TCID = "futex_wake04";
> -const int TST_TOTAL = 1;
> -
>  static futex_t *futex1, *futex2;
>  
> -static struct timespec to = {.tv_sec = 30, .tv_nsec = 0};
> +static struct tst_ts to;
>  
>  static long orig_hugepages;
>  
> +static struct test_variants {
> +	enum futex_fn_type fntype;
> +	enum tst_ts_type tstype;
> +	char *desc;
> +} variants[] = {
> +#if (__NR_futex != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX, .tstype = TST_KERN_OLD_TIMESPEC, .desc = "syscall with old kernel spec"},
> +#endif
> +
> +#if (__NR_futex_time64 != __LTP__NR_INVALID_SYSCALL)
> +	{ .fntype = FUTEX_FN_FUTEX64, .tstype = TST_KERN_TIMESPEC, .desc = "syscall time64 with kernel spec"},
> +#endif
> +};
> +
>  static void setup(void)
>  {
> -	tst_require_root();
> +	struct test_variants *tv = &variants[tst_variant];
>  
> -	if ((tst_kvercmp(2, 6, 32)) < 0) {
> -		tst_brkm(TCONF, NULL, "This test can only run on kernels "
> -			"that are 2.6.32 or higher");
> -	}
> +	tst_res(TINFO, "Testing variant: %s", tv->desc);
> +	futex_supported_by_kernel(tv->fntype);
>  
> -	if (access(PATH_HUGEPAGES, F_OK))
> -		tst_brkm(TCONF, NULL, "Huge page is not supported.");
> +	to.type = tv->tstype;
> +	tst_ts_set_sec(&to, 30);
> +	tst_ts_set_nsec(&to, 0);

Here as well.

> -	tst_tmpdir();
> +	if (access(PATH_HUGEPAGES, F_OK))
> +		tst_brk(TCONF, "Huge page is not supported.");
>  
> -	SAFE_FILE_SCANF(NULL, PATH_NR_HUGEPAGES, "%ld", &orig_hugepages);
> +	SAFE_FILE_SCANF(PATH_NR_HUGEPAGES, "%ld", &orig_hugepages);
>  
>  	if (orig_hugepages <= 0)
> -		SAFE_FILE_PRINTF(NULL, PATH_NR_HUGEPAGES, "%d", 1);
> -
> -	TEST_PAUSE;
> +		SAFE_FILE_PRINTF(PATH_NR_HUGEPAGES, "%d", 1);
>  }
>  
>  static void cleanup(void)
>  {
>  	if (orig_hugepages <= 0)
> -		SAFE_FILE_PRINTF(NULL, PATH_NR_HUGEPAGES, "%ld", orig_hugepages);
> -
> -	tst_rmdir();
> +		SAFE_FILE_PRINTF(PATH_NR_HUGEPAGES, "%ld", orig_hugepages);
>  }
>  
>  static int read_hugepagesize(void)
> @@ -97,60 +89,63 @@ static int read_hugepagesize(void)
>  	char line[BUFSIZ], buf[BUFSIZ];
>  	int val;
>  
> -	fp = SAFE_FOPEN(cleanup, PATH_MEMINFO, "r");
> +	fp = SAFE_FOPEN(PATH_MEMINFO, "r");
>  	while (fgets(line, BUFSIZ, fp) != NULL) {
>  		if (sscanf(line, "%64s %d", buf, &val) == 2)
>  			if (strcmp(buf, "Hugepagesize:") == 0) {
> -				SAFE_FCLOSE(cleanup, fp);
> +				SAFE_FCLOSE(fp);
>  				return 1024 * val;
>  			}
>  	}
>  
> -	SAFE_FCLOSE(cleanup, fp);
> -	tst_brkm(TBROK, NULL, "can't find \"%s\" in %s",
> -			"Hugepagesize:", PATH_MEMINFO);
> +	SAFE_FCLOSE(fp);
> +	tst_res(TFAIL, "can't find \"%s\" in %s", "Hugepagesize:",
> +		PATH_MEMINFO);
> +	return 0;

We just got:

commit a29f542c8b3029cc074ae5a766dfc7dca92c9225
Author: Martin Doucha <mdoucha@suse.cz>
Date:   Thu Jul 2 12:01:50 2020 +0200

    lib: Add tst_get_hugepage_size() to LTP library


>  }
>  
>  static void *wait_thread1(void *arg LTP_ATTRIBUTE_UNUSED)
>  {
> -	futex_wait(futex1, *futex1, &to, 0);
> +	struct test_variants *tv = &variants[tst_variant];
> +
> +	futex_wait(tv->fntype, futex1, *futex1, &to, 0);
>  
>  	return NULL;
>  }
>  
>  static void *wait_thread2(void *arg LTP_ATTRIBUTE_UNUSED)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	int res;
>  
> -	res = futex_wait(futex2, *futex2, &to, 0);
> +	res = futex_wait(tv->fntype, futex2, *futex2, &to, 0);
>  	if (!res)
> -		tst_resm(TPASS, "Hi hydra, thread2 awake!");
> +		tst_res(TPASS, "Hi hydra, thread2 awake!");
>  	else
> -		tst_resm(TFAIL, "Bug: wait_thread2 did not wake after 30 secs.");
> +		tst_res(TFAIL | TTERRNO, "Bug: wait_thread2 did not wake after 30 secs.");
>  
>  	return NULL;
>  }
>  
>  static void wakeup_thread2(void)
>  {
> +	struct test_variants *tv = &variants[tst_variant];
>  	void *addr;
>  	int hpsz, pgsz, res;
>  	pthread_t th1, th2;
>  
>  	hpsz = read_hugepagesize();
> -	tst_resm(TINFO, "Hugepagesize %i", hpsz);
> +	tst_res(TINFO, "Hugepagesize %i", hpsz);
>  
>  	/*allocate some shared memory*/
>  	addr = mmap(NULL, hpsz, PROT_WRITE | PROT_READ,
>  	            MAP_SHARED | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
>  
>  	if (addr == MAP_FAILED) {
> -		if (errno == ENOMEM) {
> -			tst_brkm(TCONF, NULL,
> -				 "Cannot allocate hugepage, memory too fragmented?");
> -		}
> +		if (errno == ENOMEM)
> +			tst_brk(TCONF, "Cannot allocate hugepage, memory too fragmented?");
>  
> -		tst_brkm(TBROK | TERRNO, NULL, "Cannot allocate hugepage");
> +		tst_brk(TBROK | TERRNO, "Cannot allocate hugepage");
>  	}
>  
>  	pgsz = getpagesize();
> @@ -165,45 +160,47 @@ static void wakeup_thread2(void)
>  	/*thread1 block on futex1 first,then thread2 block on futex2*/
>  	res = pthread_create(&th1, NULL, wait_thread1, NULL);
>  	if (res) {
> -		tst_brkm(TBROK, NULL, "pthread_create(): %s",
> -				tst_strerrno(res));
> +		tst_res(TFAIL | TTERRNO, "pthread_create() failed");

Here as well SAFE_PTHREAD().

> +		return;
>  	}
>  
>  	res = pthread_create(&th2, NULL, wait_thread2, NULL);
>  	if (res) {
> -		tst_brkm(TBROK, NULL, "pthread_create(): %s",
> -				tst_strerrno(res));
> +		tst_res(TFAIL | TTERRNO, "pthread_create() failed");
> +		return;
>  	}
>  
>  	while (wait_for_threads(2))
>  		usleep(1000);
>  
> -	futex_wake(futex2, 1, 0);
> +	futex_wake(tv->fntype, futex2, 1, 0);
>  
>  	res = pthread_join(th2, NULL);
> -	if (res)
> -		tst_brkm(TBROK, NULL, "pthread_join(): %s", tst_strerrno(res));
> +	if (res) {
> +		tst_res(TFAIL | TTERRNO, "pthread_join() failed");
> +		return;
> +	}
>  
> -	futex_wake(futex1, 1, 0);
> +	futex_wake(tv->fntype, futex1, 1, 0);
>  
>  	res = pthread_join(th1, NULL);
>  	if (res)
> -		tst_brkm(TBROK, NULL, "pthread_join(): %s", tst_strerrno(res));
> +		tst_res(TFAIL | TTERRNO, "pthread_join() failed");
>  
> -	SAFE_MUNMAP(NULL, addr, hpsz);
> +	SAFE_MUNMAP(addr, hpsz);
>  }
>  
> -int main(int argc, char *argv[])
> +static void run(void)
>  {
> -	int lc;
> -
> -	tst_parse_opts(argc, argv, NULL, NULL);
> -
> -	setup();
> -
> -	for (lc = 0; TEST_LOOPING(lc); lc++)
> -		wakeup_thread2();
> -
> -	cleanup();
> -	tst_exit();
> +	wakeup_thread2();
>  }
> +
> +static struct tst_test test = {
> +	.setup = setup,
> +	.cleanup = cleanup,
> +	.test_all = run,
> +	.test_variants = ARRAY_SIZE(variants),
> +	.needs_root = 1,
> +	.min_kver = "2.6.32",
> +	.needs_tmpdir = 1,
> +};
> diff --git a/testcases/kernel/syscalls/futex/futextest.h b/testcases/kernel/syscalls/futex/futextest.h
> index 5754d36dae51..b72d83bc711b 100644
> --- a/testcases/kernel/syscalls/futex/futextest.h
> +++ b/testcases/kernel/syscalls/futex/futextest.h
> @@ -39,6 +39,7 @@
>  #include <sys/types.h>
>  #include <linux/futex.h>
>  #include "lapi/futex.h"
> +#include "tst_timer.h"
>  
>  #define FUTEX_INITIALIZER 0
>  
> @@ -82,18 +83,35 @@
>  # define FUTEX_CLOCK_REALTIME 256
>  #endif
>  
> +enum futex_fn_type {
> +	FUTEX_FN_FUTEX,
> +	FUTEX_FN_FUTEX64,
> +};
> +
> +static inline void futex_supported_by_kernel(enum futex_fn_type fntype)
> +{
> +	if (fntype != FUTEX_FN_FUTEX64)
> +		return;
> +
> +	/* Check if the syscall is implemented on the platform */
> +	TEST(sys_futex_time64(NULL, 0, 0, NULL, NULL, 0));
> +	if (TST_RET == -1 && TST_ERR == ENOSYS)
> +		tst_brk(TCONF, "Test not supported on kernel/platform");
> +}
> +
>  /**
> - * futex() - SYS_futex syscall wrapper
> + * futex_syscall() - futex syscall wrapper
> + * @fntype:	Futex function type
>   * @uaddr:	address of first futex
>   * @op:		futex op code
>   * @val:	typically expected value of uaddr, but varies by op
> - * @timeout:	typically an absolute struct timespec (except where noted
> + * @timeout:	typically an absolute struct tst_ts (except where noted
>   *		otherwise). Overloaded by some ops
>   * @uaddr2:	address of second futex for some ops\
>   * @val3:	varies by op
>   * @opflags:	flags to be bitwise OR'd with op, such as FUTEX_PRIVATE_FLAG
>   *
> - * futex() is used by all the following futex op wrappers. It can also be
> + * futex_syscall() is used by all the following futex op wrappers. It can also be
>   * used for misuse and abuse testing. Generally, the specific op wrappers
>   * should be used instead. It is a macro instead of an static inline function as
>   * some of the types over overloaded (timeout is used for nr_requeue for
> @@ -102,17 +120,30 @@
>   * These argument descriptions are the defaults for all
>   * like-named arguments in the following wrappers except where noted below.
>   */
> -#define futex(uaddr, op, val, timeout, uaddr2, val3, opflags) \
> -	syscall(SYS_futex, uaddr, op | opflags, val, timeout, uaddr2, val3)
> +static inline int futex_syscall(enum futex_fn_type fntype, futex_t *uaddr,
> +				int futex_op, futex_t val, void *timeout,
> +				futex_t *uaddr2, int val3, int opflags)
> +{
> +	int (*func)(int *uaddr, int futex_op, int val, void *to, int *uaddr2, int val3);
> +
> +	if (fntype == FUTEX_FN_FUTEX)
> +		func = sys_futex;
> +	else
> +		func = sys_futex_time64;
> +
> +	return func((int *)uaddr, futex_op | opflags, val, timeout, (int *)uaddr2, val3);
> +}
>  
>  /**
>   * futex_wait() - block on uaddr with optional timeout
>   * @timeout:	relative timeout
>   */
>  static inline int
> -futex_wait(futex_t *uaddr, futex_t val, struct timespec *timeout, int opflags)
> +futex_wait(enum futex_fn_type fntype, futex_t *uaddr, futex_t val,
> +	   struct tst_ts *timeout, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAIT, val, timeout, NULL, 0, opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAIT, val,
> +			     tst_ts_get(timeout), NULL, 0, opflags);
>  }
>  
>  /**
> @@ -120,9 +151,10 @@ futex_wait(futex_t *uaddr, futex_t val, struct timespec *timeout, int opflags)
>   * @nr_wake:	wake up to this many tasks
>   */
>  static inline int
> -futex_wake(futex_t *uaddr, int nr_wake, int opflags)
> +futex_wake(enum futex_fn_type fntype, futex_t *uaddr, int nr_wake, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAKE, nr_wake, NULL, NULL, 0, opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAKE, nr_wake, NULL, NULL, 0,
> +			     opflags);
>  }
>  
>  /**
> @@ -130,11 +162,11 @@ futex_wake(futex_t *uaddr, int nr_wake, int opflags)
>   * @bitset:	bitset to be used with futex_wake_bitset
>   */
>  static inline int
> -futex_wait_bitset(futex_t *uaddr, futex_t val, struct timespec *timeout,
> -		  u_int32_t bitset, int opflags)
> +futex_wait_bitset(enum futex_fn_type fntype, futex_t *uaddr, futex_t val,
> +		  struct tst_ts *timeout, u_int32_t bitset, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAIT_BITSET, val, timeout, NULL, bitset,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAIT_BITSET, val,
> +			     tst_ts_get(timeout), NULL, bitset, opflags);
>  }
>  
>  /**
> @@ -142,10 +174,11 @@ futex_wait_bitset(futex_t *uaddr, futex_t val, struct timespec *timeout,
>   * @bitset:	bitset to compare with that used in futex_wait_bitset
>   */
>  static inline int
> -futex_wake_bitset(futex_t *uaddr, int nr_wake, u_int32_t bitset, int opflags)
> +futex_wake_bitset(enum futex_fn_type fntype, futex_t *uaddr, int nr_wake,
> +		  u_int32_t bitset, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAKE_BITSET, nr_wake, NULL, NULL, bitset,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAKE_BITSET, nr_wake, NULL,
> +			     NULL, bitset, opflags);
>  }
>  
>  /**
> @@ -153,30 +186,32 @@ futex_wake_bitset(futex_t *uaddr, int nr_wake, u_int32_t bitset, int opflags)
>   * @detect:	whether (1) or not (0) to perform deadlock detection
>   */
>  static inline int
> -futex_lock_pi(futex_t *uaddr, struct timespec *timeout, int detect,
> -	      int opflags)
> +futex_lock_pi(enum futex_fn_type fntype, futex_t *uaddr, struct tst_ts *timeout,
> +	      int detect, int opflags)
>  {
> -	return futex(uaddr, FUTEX_LOCK_PI, detect, timeout, NULL, 0, opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_LOCK_PI, detect,
> +			     tst_ts_get(timeout), NULL, 0, opflags);
>  }
>  
>  /**
>   * futex_unlock_pi() - release uaddr as a PI mutex, waking the top waiter
>   */
>  static inline int
> -futex_unlock_pi(futex_t *uaddr, int opflags)
> +futex_unlock_pi(enum futex_fn_type fntype, futex_t *uaddr, int opflags)
>  {
> -	return futex(uaddr, FUTEX_UNLOCK_PI, 0, NULL, NULL, 0, opflags);
> -}
> +	return futex_syscall(fntype, uaddr, FUTEX_UNLOCK_PI, 0, NULL, NULL, 0,
> +			     opflags); }
>  
>  /**
>   * futex_wake_op() - FIXME: COME UP WITH A GOOD ONE LINE DESCRIPTION
>   */
>  static inline int
> -futex_wake_op(futex_t *uaddr, futex_t *uaddr2, int nr_wake, int nr_wake2,
> -	      int wake_op, int opflags)
> +futex_wake_op(enum futex_fn_type fntype, futex_t *uaddr, futex_t *uaddr2,
> +	      int nr_wake, int nr_wake2, int wake_op, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAKE_OP, nr_wake, nr_wake2, uaddr2, wake_op,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAKE_OP, nr_wake,
> +			     (void *)((unsigned long)nr_wake2), uaddr2, wake_op,
> +			     opflags);
>  }
>  
>  /**
> @@ -188,11 +223,12 @@ futex_wake_op(futex_t *uaddr, futex_t *uaddr2, int nr_wake, int nr_wake2,
>   * favor of futex_cmp_requeue().
>   */
>  static inline int
> -futex_requeue(futex_t *uaddr, futex_t *uaddr2, int nr_wake, int nr_requeue,
> -	      int opflags)
> +futex_requeue(enum futex_fn_type fntype, futex_t *uaddr, futex_t *uaddr2,
> +	      int nr_wake, int nr_requeue, int opflags)
>  {
> -	return futex(uaddr, FUTEX_REQUEUE, nr_wake, nr_requeue, uaddr2, 0,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_REQUEUE, nr_wake,
> +			     (void *)((unsigned long)nr_requeue), uaddr2, 0,
> +			     opflags);
>  }
>  
>  /**
> @@ -201,11 +237,12 @@ futex_requeue(futex_t *uaddr, futex_t *uaddr2, int nr_wake, int nr_requeue,
>   * @nr_requeue:	requeue up to this many tasks
>   */
>  static inline int
> -futex_cmp_requeue(futex_t *uaddr, futex_t val, futex_t *uaddr2, int nr_wake,
> -		  int nr_requeue, int opflags)
> +futex_cmp_requeue(enum futex_fn_type fntype, futex_t *uaddr, futex_t val,
> +		  futex_t *uaddr2, int nr_wake, int nr_requeue, int opflags)
>  {
> -	return futex(uaddr, FUTEX_CMP_REQUEUE, nr_wake, nr_requeue, uaddr2,
> -		     val, opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_CMP_REQUEUE, nr_wake,
> +			     (void *)((unsigned long)nr_requeue), uaddr2, val,
> +			     opflags);
>  }
>  
>  /**
> @@ -217,11 +254,11 @@ futex_cmp_requeue(futex_t *uaddr, futex_t val, futex_t *uaddr2, int nr_wake,
>   * paired with futex_cmp_requeue_pi().
>   */
>  static inline int
> -futex_wait_requeue_pi(futex_t *uaddr, futex_t val, futex_t *uaddr2,
> -		      struct timespec *timeout, int opflags)
> +futex_wait_requeue_pi(enum futex_fn_type fntype, futex_t *uaddr, futex_t val,
> +		      futex_t *uaddr2, struct tst_ts *timeout, int opflags)
>  {
> -	return futex(uaddr, FUTEX_WAIT_REQUEUE_PI, val, timeout, uaddr2, 0,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_WAIT_REQUEUE_PI, val,
> +			     tst_ts_get(timeout), uaddr2, 0, opflags);
>  }
>  
>  /**
> @@ -232,11 +269,12 @@ futex_wait_requeue_pi(futex_t *uaddr, futex_t val, futex_t *uaddr2,
>   * @nr_requeue:	requeue up to this many tasks
>   */
>  static inline int
> -futex_cmp_requeue_pi(futex_t *uaddr, futex_t val, futex_t *uaddr2, int nr_wake,
> -		     int nr_requeue, int opflags)
> +futex_cmp_requeue_pi(enum futex_fn_type fntype, futex_t *uaddr, futex_t val,
> +		     futex_t *uaddr2, int nr_wake, int nr_requeue, int opflags)
>  {
> -	return futex(uaddr, FUTEX_CMP_REQUEUE_PI, nr_wake, nr_requeue, uaddr2, val,
> -		     opflags);
> +	return futex_syscall(fntype, uaddr, FUTEX_CMP_REQUEUE_PI, nr_wake,
> +			     (void *)((unsigned long)nr_requeue), uaddr2, val,
> +			     opflags);
>  }
>  
>  /**
> -- 
> 2.25.0.rc1.19.g042ed3e048af
>

On 03-07-20, 14:45, Cyril Hrubis wrote:
> > diff --git a/testcases/kernel/syscalls/futex/futex_wait05.c b/testcases/kernel/syscalls/futex/futex_wait05.c
> > index 2573ae177d5b..8fad5d858716 100644
> > --- a/testcases/kernel/syscalls/futex/futex_wait05.c
> > +++ b/testcases/kernel/syscalls/futex/futex_wait05.c
> > @@ -19,7 +19,7 @@ int sample_fn(int clk_id, long long usec)
> >  	futex_t futex = FUTEX_INITIALIZER;
> >  
> >  	tst_timer_start(clk_id);
> > -	TEST(futex_wait(&futex, futex, &to, 0));
> > +	TEST(syscall(SYS_futex, &futex, FUTEX_WAIT, futex, &to, NULL, 0));
> >  	tst_timer_stop();
> >  	tst_timer_sample();
> 
> Why aren't we adding the two functions here as well?

I am not sure which two functions are you talking about here ..

> Is the timer library incompatible with test variants?

On 06-07-20, 16:10, Viresh Kumar wrote:
> On 03-07-20, 14:45, Cyril Hrubis wrote:
> > > diff --git a/testcases/kernel/syscalls/futex/futex_wait05.c b/testcases/kernel/syscalls/futex/futex_wait05.c
> > > index 2573ae177d5b..8fad5d858716 100644
> > > --- a/testcases/kernel/syscalls/futex/futex_wait05.c
> > > +++ b/testcases/kernel/syscalls/futex/futex_wait05.c
> > > @@ -19,7 +19,7 @@ int sample_fn(int clk_id, long long usec)
> > >  	futex_t futex = FUTEX_INITIALIZER;
> > >  
> > >  	tst_timer_start(clk_id);
> > > -	TEST(futex_wait(&futex, futex, &to, 0));
> > > +	TEST(syscall(SYS_futex, &futex, FUTEX_WAIT, futex, &to, NULL, 0));
> > >  	tst_timer_stop();
> > >  	tst_timer_sample();
> > 
> > Why aren't we adding the two functions here as well?
> 
> I am not sure which two functions are you talking about here ..
> 
> > Is the timer library incompatible with test variants?

I kept staring at this code and your comment and may have understood
finally :)

I haven't added futex variants here as this uses the _sample_
callback, which works with the simple timer code in LTP and as I
remember from some earlier discussion, that would be a lot of changes
and may not be worth it.