Convert nanosleep02 to newlib

index 42c825190..2abe38a95 100644
@@ -26,24 +26,10 @@
  */
 
 #include <errno.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <signal.h>
-#include <time.h>
-#include <sys/wait.h>
-#include <sys/time.h>
-#include <stdint.h>
-#include <inttypes.h>
 
-#include "test.h"
-#include "safe_macros.h"
-
-char *TCID = "nanosleep02";
-int TST_TOTAL = 1;
-
-static void do_child(void);
-static void setup(void);
-static void sig_handler();
+#include "tst_test.h"
+#include "tst_timer.h"
+#include "tst_safe_macros.h"
 
 /*
  * Define here the "rem" precision in microseconds,

@@ -57,50 +43,6 @@ static void sig_handler();
  */
 #define USEC_PRECISION 250000	/* Error margin allowed in usec */
 
-int main(int ac, char **av)
-{
-	int lc;
-	pid_t cpid;
-
-	tst_parse_opts(ac, av, NULL, NULL);
-
-#ifdef UCLINUX
-	maybe_run_child(&do_child, "");
-#endif
-
-	setup();
-
-	for (lc = 0; TEST_LOOPING(lc); lc++) {
-
-		tst_count = 0;
-
-		if ((cpid = FORK_OR_VFORK()) == -1) {
-			tst_brkm(TBROK, NULL,
-				 "fork() failed to create child process");
-		}
-
-		if (cpid == 0) {
-#ifdef UCLINUX
-			if (self_exec(av[0], "")) {
-				tst_brkm(TBROK, NULL, "self_exec failed");
-			}
-#else
-			do_child();
-#endif
-		}
-
-		/* wait for child to time slot for execution */
-		sleep(1);
-
-		/* Now send signal to child */
-		SAFE_KILL(NULL, cpid, SIGINT);
-
-		tst_record_childstatus(NULL, cpid);
-	}
-
-	tst_exit();
-}
-
 static void do_child(void)
 {
 	struct timespec timereq = {.tv_sec = 5, .tv_nsec = 9999};

@@ -110,42 +52,57 @@ static void do_child(void)
 	TEST(nanosleep(&timereq, &timerem));
 	tst_timer_stop();
 
-	if (tst_timespec_lt(timereq, tst_timer_elapsed())) {
-		tst_resm(TFAIL, "nanosleep() slept more than timereq");
-		return;
-	}
+	if (!TST_RET)
+		tst_brk(TBROK, "nanosleep was not interrupted");
+	if (TST_ERR != EINTR)
+		tst_brk(TBROK | TTERRNO, "nanosleep() failed");
+
+	if (tst_timespec_lt(timereq, tst_timer_elapsed()))
+		tst_brk(TFAIL, "nanosleep() slept more than timereq");
 
 	exp_rem = tst_timespec_diff(timereq, tst_timer_elapsed());
 
 	if (tst_timespec_abs_diff_us(timerem, exp_rem) > USEC_PRECISION) {
-		tst_resm(TFAIL,
-		         "nanosleep() remaining time %llius, expected %llius, diff %llius",
-			 tst_timespec_to_us(timerem), tst_timespec_to_us(exp_rem),
-			 tst_timespec_abs_diff_us(timerem, exp_rem));
+		tst_res(TFAIL,
+			"nanosleep() remaining time %llius, expected %llius, diff %llius",
+			tst_timespec_to_us(timerem), tst_timespec_to_us(exp_rem),
+			tst_timespec_abs_diff_us(timerem, exp_rem));
 	} else {
-		tst_resm(TPASS,
-		         "nanosleep() slept for %llius, remaining time difference %llius",
-			 tst_timer_elapsed_us(),
-		         tst_timespec_abs_diff_us(timerem, exp_rem));
+		tst_res(TPASS,
+			"nanosleep() slept for %llius, remaining time difference %llius",
+			tst_timer_elapsed_us(),
+			tst_timespec_abs_diff_us(timerem, exp_rem));
 	}
-
-	tst_exit();
 }
 
-static void setup(void)
+void run(void)
 {
-	tst_sig(FORK, DEF_HANDLER, NULL);
+	pid_t cpid;
 
-	tst_timer_check(CLOCK_MONOTONIC);
+	cpid = SAFE_FORK();
+	if (cpid == 0) {
+		do_child();
+	} else {
+		sleep(1);
 
-	TEST_PAUSE;
+		SAFE_KILL(cpid, SIGINT);
 
-	if (signal(SIGINT, sig_handler) == SIG_ERR) {
-		tst_brkm(TBROK, NULL,
-			 "signal() fails to setup signal handler");
+		tst_reap_children();
 	}
 }
 
-static void sig_handler(void)
+static void sig_handler(int si LTP_ATTRIBUTE_UNUSED)
+{
+}
+
+static void setup(void)
 {
+	tst_timer_check(CLOCK_MONOTONIC);
+	SAFE_SIGNAL(SIGINT, sig_handler);
 }
+
+static struct tst_test test = {
+	.forks_child = 1,
+	.setup = setup,
+	.test_all = run,
+};

index 13616c65f..b45cd90b5 100644
@@ -28,8 +28,9 @@
 
 #include <errno.h>
 
-#include "test.h"
-#include "safe_macros.h"
+#include "tst_test.h"
+#include "tst_timer.h"
+#include "tst_safe_macros.h"
 
 /*
  * MIN_TIME_LIMIT is defined to 5 senconds as a minimal acceptable

@@ -50,10 +51,8 @@
 #define FILE_MODE	(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID)
 #define PATH_LS_BRK_T	"/proc/sys/fs/lease-break-time"
 
-static void setup(void);
-static void do_test(int);
-static int do_child(int);
-static void cleanup(void);
+static void do_test(unsigned int);
+static void do_child(unsigned int);
 
 static int fd;
 static int ls_brk_t;

@@ -84,113 +83,86 @@ static struct test_case_t {
 		"truncate() conflicts with fcntl(F_SETLEASE, F_RDLCK)"},
 };
 
-char *TCID = "fcntl33";
-int TST_TOTAL = ARRAY_SIZE(test_cases);
-
-int main(int ac, char **av)
-{
-	int lc;
-	int tc;
-
-	tst_parse_opts(ac, av, NULL, NULL);
-
-	setup();
-
-	for (lc = 0; TEST_LOOPING(lc); lc++) {
-		tst_count = 0;
-
-		for (tc = 0; tc < TST_TOTAL; tc++)
-			do_test(tc);
-	}
-
-	cleanup();
-	tst_exit();
-}
-
 static void setup(void)
 {
-	tst_sig(FORK, DEF_HANDLER, cleanup);
-
-	tst_require_root();
-
 	tst_timer_check(CLOCK_MONOTONIC);
 
 	/* Backup and set the lease-break-time. */
-	SAFE_FILE_SCANF(NULL, PATH_LS_BRK_T, "%d", &ls_brk_t);
-	SAFE_FILE_PRINTF(NULL, PATH_LS_BRK_T, "%d", 45);
+	SAFE_FILE_SCANF(PATH_LS_BRK_T, "%d", &ls_brk_t);
+	SAFE_FILE_PRINTF(PATH_LS_BRK_T, "%d", 45);
 
-	tst_tmpdir();
-
-	switch ((type = tst_fs_type(cleanup, "."))) {
+	switch ((type = tst_fs_type("."))) {
 	case TST_NFS_MAGIC:
 	case TST_RAMFS_MAGIC:
 	case TST_TMPFS_MAGIC:
-		tst_brkm(TCONF, cleanup,
-			 "Cannot do fcntl(F_SETLEASE, F_WRLCK) "
-			 "on %s filesystem",
-			 tst_fs_type_name(type));
+		tst_brk(TCONF,
+			"Cannot do fcntl(F_SETLEASE, F_WRLCK) on %s filesystem",
+			tst_fs_type_name(type));
 	default:
 		break;
 	}
 
-	SAFE_TOUCH(cleanup, "file", FILE_MODE, NULL);
+	SAFE_TOUCH("file", FILE_MODE, NULL);
 
 	sigemptyset(&newset);
 	sigaddset(&newset, SIGIO);
 
 	if (sigprocmask(SIG_SETMASK, &newset, &oldset) < 0)
-		tst_brkm(TBROK | TERRNO, cleanup, "sigprocmask() failed");
-
-	TEST_PAUSE;
+		tst_brk(TBROK | TERRNO, "sigprocmask() failed");
 }
 
-static void do_test(int i)
+static void do_test(unsigned int i)
 {
-	fd = SAFE_OPEN(cleanup, "file", O_RDONLY);
-
-	pid_t cpid = tst_fork();
-
-	if (cpid < 0)
-		tst_brkm(TBROK | TERRNO, cleanup, "fork() failed");
+	pid_t cpid;
 
+	cpid = SAFE_FORK();
 	if (cpid == 0) {
-		SAFE_CLOSE(NULL, fd);
 		do_child(i);
+		return;
 	}
 
+	fd = SAFE_OPEN("file", O_RDONLY);
+
 	TEST(fcntl(fd, F_SETLEASE, test_cases[i].lease_type));
-	if (TEST_RETURN == -1) {
-		tst_resm(TFAIL | TTERRNO, "fcntl() failed to set lease");
-		SAFE_WAITPID(cleanup, cpid, NULL, 0);
-		SAFE_CLOSE(cleanup, fd);
-		fd = 0;
-		return;
+	if (TST_RET == -1) {
+		tst_res(TFAIL | TTERRNO, "fcntl() failed to set lease");
+		goto exit;
 	}
 
 	/* Wait for SIGIO caused by lease breaker. */
 	TEST(sigtimedwait(&newset, NULL, &timeout));
-	if (TEST_RETURN == -1) {
-		if (TEST_ERRNO == EAGAIN) {
-			tst_resm(TFAIL | TTERRNO, "failed to receive SIGIO "
-				 "within %lis", timeout.tv_sec);
-			SAFE_WAITPID(cleanup, cpid, NULL, 0);
-			SAFE_CLOSE(cleanup, fd);
-			fd = 0;
-			return;
+	if (TST_RET == -1) {
+		if (TST_ERR == EAGAIN) {
+			tst_res(TFAIL | TTERRNO,
+				"failed to receive SIGIO within %lis",
+				timeout.tv_sec);
+			goto exit;
 		}
-		tst_brkm(TBROK | TTERRNO, cleanup, "sigtimedwait() failed");
+		tst_brk(TBROK | TTERRNO, "sigtimedwait() failed");
 	}
 
 	/* Try to downgrade or remove the lease. */
 	switch (test_cases[i].lease_type) {
 	case F_WRLCK:
 		TEST(fcntl(fd, F_SETLEASE, F_RDLCK));
-		if (TEST_RETURN == 0)
-			break;
+		if (TST_RET == 0) {
+			if (test_cases[i].op_type == OP_OPEN_RDONLY)
+				break;
+
+			tst_res(TFAIL,
+				"fcntl() downgraded lease when not read-only");
+		}
+
+		if (test_cases[i].op_type == OP_OPEN_RDONLY) {
+			tst_res(TFAIL | TTERRNO,
+				"fcntl() failed to downgrade lease");
+		}
+
+		/* Falls through */
 	case F_RDLCK:
 		TEST(fcntl(fd, F_SETLEASE, F_UNLCK));
-		if (TEST_RETURN == -1) {
-			tst_resm(TFAIL | TTERRNO,
+		if (TST_RET == -1) {
+			tst_res(TFAIL | TTERRNO,
 				 "fcntl() failed to remove the lease");
 		}
 		break;

@@ -198,35 +170,31 @@ static void do_test(int i)
 		break;
 	}
 
-	tst_record_childstatus(cleanup, cpid);
-
-	SAFE_CLOSE(cleanup, fd);
-	fd = 0;
+exit:
+	tst_reap_children();
+	SAFE_CLOSE(fd);
 }
 
-static int do_child(int i)
+static void do_child(unsigned int i)
 {
 	long long elapsed_ms;
 
-	if (tst_process_state_wait2(getppid(), 'S') != 0) {
-		tst_brkm(TBROK | TERRNO, NULL,
-			 "failed to wait for parent process's state");
-	}
+	TST_PROCESS_STATE_WAIT(getppid(), 'S');
 
 	tst_timer_start(CLOCK_MONOTONIC);
 
 	switch (test_cases[i].op_type) {
 	case OP_OPEN_RDONLY:
-		SAFE_OPEN(NULL, "file", O_RDONLY);
+		SAFE_OPEN("file", O_RDONLY);
 		break;
 	case OP_OPEN_WRONLY:
-		SAFE_OPEN(NULL, "file", O_WRONLY);
+		SAFE_OPEN("file", O_WRONLY);
 		break;
 	case OP_OPEN_RDWR:
-		SAFE_OPEN(NULL, "file", O_RDWR);
+		SAFE_OPEN("file", O_RDWR);
 		break;
 	case OP_TRUNCATE:
-		SAFE_TRUNCATE(NULL, "file", 0);
+		SAFE_TRUNCATE("file", 0);
 		break;
 	default:
 		break;

@@ -237,27 +205,33 @@ static int do_child(int i)
 	elapsed_ms = tst_timer_elapsed_ms();
 
 	if (elapsed_ms < MIN_TIME_LIMIT * 1000) {
-		tst_resm(TPASS, "%s, unblocked within %ds",
+		tst_res(TPASS, "%s, unblocked within %ds",
 			 test_cases[i].desc, MIN_TIME_LIMIT);
 	} else {
-		tst_resm(TFAIL, "%s, blocked too long %llims, "
-			 "expected within %ds",
-			 test_cases[i].desc, elapsed_ms, MIN_TIME_LIMIT);
+		tst_res(TFAIL,
+			"%s, blocked too long %llims, expected within %ds",
+			test_cases[i].desc, elapsed_ms, MIN_TIME_LIMIT);
 	}
-
-	tst_exit();
 }
 
 static void cleanup(void)
 {
 	if (sigprocmask(SIG_SETMASK, &oldset, NULL) < 0)
-		tst_resm(TWARN | TERRNO, "sigprocmask restore oldset failed");
+		tst_res(TWARN | TERRNO, "sigprocmask restore oldset failed");
 
-	if (fd > 0 && close(fd))
-		tst_resm(TWARN | TERRNO, "failed to close file");
-
-	tst_rmdir();
+	if (fd > 0)
+		SAFE_CLOSE(fd);
 
 	/* Restore the lease-break-time. */
 	FILE_PRINTF(PATH_LS_BRK_T, "%d", ls_brk_t);
 }
+
+static struct tst_test test = {
+	.forks_child = 1,
+	.needs_root = 1,
+	.needs_tmpdir = 1,
+	.tcnt = ARRAY_SIZE(test_cases),
+	.setup = setup,
+	.test = do_test,
+	.cleanup = cleanup
+};

index 81a5d93ab..090dc51d2 100644
@@ -18,6 +18,7 @@
  */
 
 #define TRESHOLD_US 100000
+#define DEFAULT_TIMEOUT_US 100010
 
 static void verify_futex_wait_bitset(long long wait_us, clock_t clk_id)
 {

@@ -26,8 +27,8 @@ static void verify_futex_wait_bitset(long long wait_us, clock_t clk_id)
 	u_int32_t bitset = 0xffffffff;
 	int flags = clk_id == CLOCK_REALTIME ? FUTEX_CLOCK_REALTIME : 0;
 
-	tst_resm(TINFO, "testing futex_wait_bitset() timeout with %s",
-	         clk_id == CLOCK_REALTIME ? "CLOCK_REALTIME" : "CLOCK_MONOTONIC");
+	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);

@@ -36,38 +37,53 @@ static void verify_futex_wait_bitset(long long wait_us, clock_t clk_id)
 
 	clock_gettime(clk_id, &end);
 
-	if (TEST_RETURN != -1) {
-		tst_resm(TFAIL, "futex_wait_bitset() returned %li, expected -1",
-		         TEST_RETURN);
+	if (TST_RET != -1) {
+		tst_res(TFAIL, "futex_wait_bitset() returned %li, expected -1",
+			TST_RET);
 		return;
 	}
 
-	if (TEST_ERRNO == ENOSYS) {
-		tst_resm(TCONF, "In this kernel, futex() does not support "
-			 "FUTEX_WAIT_BITSET operation");
+	if (TST_ERR == ENOSYS) {
+		tst_res(TCONF,
+			"In this kernel, futex() does not support FUTEX_WAIT_BITSET operation");
 		return;
 	}
 
-	if (TEST_ERRNO != ETIMEDOUT) {
-		tst_resm(TFAIL | TTERRNO, "expected %s",
-		         tst_strerrno(ETIMEDOUT));
+	if (TST_ERR != ETIMEDOUT) {
+		tst_res(TFAIL | TTERRNO, "expected %s",
+			tst_strerrno(ETIMEDOUT));
 		return;
 	}
 
 	if (tst_timespec_lt(end, to)) {
-		tst_resm(TFAIL,
-		         "futex_wait_bitset() woken up prematurely %llius, expected %llius",
-			 tst_timespec_diff_us(end, start), wait_us);
+		tst_res(TFAIL,
+			"futex_wait_bitset() woken up prematurely %llius, expected %llius",
+			tst_timespec_diff_us(end, start), wait_us);
 		return;
 	}
 
 	if (tst_timespec_diff_us(end, to) > TRESHOLD_US) {
-		tst_resm(TFAIL,
-		         "futex_wait_bitset() waited too long %llius, expected %llius",
-			 tst_timespec_diff_us(end, start), wait_us);
+		tst_res(TFAIL,
+			"futex_wait_bitset() waited too long %llius, expected %llius",
+			tst_timespec_diff_us(end, start), wait_us);
 		return;
 	}
 
-	tst_resm(TPASS, "futex_wait_bitset() waited %llius, expected %llius",
-	         tst_timespec_diff_us(end, start), wait_us);
+	tst_res(TPASS, "futex_wait_bitset() waited %llius, expected %llius",
+		tst_timespec_diff_us(end, start), wait_us);
 }
+
+static void setup(void)
+{
+	tst_timer_check(USE_CLOCK);
+}
+
+static void run(void)
+{
+	verify_futex_wait_bitset(DEFAULT_TIMEOUT_US, USE_CLOCK);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test_all = run,
+};

index e5fd621e5..371febb3b 100644
@@ -24,25 +24,11 @@
 
 #include <errno.h>
 
-#include "test.h"
+#include "tst_test.h"
+#include "tst_timer.h"
 #include "futextest.h"
-#include "futex_wait_bitset.h"
-
-const char *TCID="futex_wait_bitset01";
-const int TST_TOTAL=1;
-
-#define DEFAULT_TIMEOUT_US 100010
 
-int main(int argc, char *argv[])
-{
-	int lc;
+#define USE_CLOCK CLOCK_MONOTONIC
 
-	tst_timer_check(CLOCK_MONOTONIC);
-
-	tst_parse_opts(argc, argv, NULL, NULL);
-
-	for (lc = 0; TEST_LOOPING(lc); lc++)
-		verify_futex_wait_bitset(DEFAULT_TIMEOUT_US, CLOCK_MONOTONIC);
+#include "futex_wait_bitset.h"
 
-	tst_exit();
-}

index 820c65c26..e727a1b38 100644
@@ -24,25 +24,10 @@
 
 #include <errno.h>
 
-#include "test.h"
+#include "tst_test.h"
+#include "tst_timer.h"
 #include "futextest.h"
-#include "futex_wait_bitset.h"
-
-const char *TCID="futex_wait_bitset02";
-const int TST_TOTAL=1;
-
-#define DEFAULT_TIMEOUT_US 100010
-
-int main(int argc, char *argv[])
-{
-	int lc;
 
-	tst_timer_check(CLOCK_REALTIME);
+#define USE_CLOCK CLOCK_REALTIME
 
-	tst_parse_opts(argc, argv, NULL, NULL);
-
-	for (lc = 0; TEST_LOOPING(lc); lc++)
-		verify_futex_wait_bitset(DEFAULT_TIMEOUT_US, CLOCK_REALTIME);
-
-	tst_exit();
-}
+#include "futex_wait_bitset.h"

index 5eef304ab..8597cb1c6 100644
@@ -53,7 +53,6 @@
 #include "tst_process_state.h"
 #include "old_resource.h"
 #include "tst_res_flags.h"
-#include "tst_timer.h"
 #include "tst_kvercmp.h"
 #include "tst_fs.h"
 #include "tst_pid.h"

index 53ff36777..d5e4c49d2 100644
@@ -23,7 +23,9 @@
 
 #include <errno.h>
 
-#include "test.h"
+#define TST_NO_DEFAULT_MAIN
+
+#include "tst_test.h"
 #include "tst_timer.h"
 #include "tst_clocks.h"
 #include "lapi/posix_clocks.h"

@@ -59,13 +61,13 @@ void tst_timer_check(clockid_t clk_id)
 {
 	if (tst_clock_gettime(clk_id, &start_time)) {
 		if (errno == EINVAL) {
-			tst_brkm(TCONF, NULL,
+			tst_brk(TCONF,
 			         "Clock id %s(%u) not supported by kernel",
 				 clock_name(clk_id), clk_id);
 			return;
 		}
 
-		tst_brkm(TBROK | TERRNO, NULL, "tst_clock_gettime() failed");
+		tst_brk(TBROK | TERRNO, "tst_clock_gettime() failed");
 	}
 }
 

@@ -74,7 +76,7 @@ void tst_timer_start(clockid_t clk_id)
 	clock_id = clk_id;
 
 	if (tst_clock_gettime(clock_id, &start_time))
-		tst_resm(TWARN | TERRNO, "tst_clock_gettime() failed");
+		tst_res(TWARN | TERRNO, "tst_clock_gettime() failed");
 }
 
 int tst_timer_expired_ms(long long ms)

@@ -82,7 +84,7 @@ int tst_timer_expired_ms(long long ms)
 	struct timespec cur_time;
 
 	if (tst_clock_gettime(clock_id, &cur_time))
-		tst_resm(TWARN | TERRNO, "tst_clock_gettime() failed");
+		tst_res(TWARN | TERRNO, "tst_clock_gettime() failed");
 
 	return tst_timespec_diff_ms(cur_time, start_time) >= ms;
 }

@@ -90,7 +92,7 @@ int tst_timer_expired_ms(long long ms)
 void tst_timer_stop(void)
 {
 	if (tst_clock_gettime(clock_id, &stop_time))
-		tst_resm(TWARN | TERRNO, "tst_clock_gettime() failed");
+		tst_res(TWARN | TERRNO, "tst_clock_gettime() failed");
 }
 
 struct timespec tst_timer_elapsed(void)