syscalls/clock_settime01.c: create syscall clock_settime test

---
 runtest/syscalls                              |   2 +
 .../kernel/syscalls/clock_settime/.gitignore  |   1 +
 .../kernel/syscalls/clock_settime/Makefile    |   8 +
 .../syscalls/clock_settime/clock_settime01.c  | 187 ++++++++++++++++++
 4 files changed, 198 insertions(+)
 create mode 100644 testcases/kernel/syscalls/clock_settime/.gitignore
 create mode 100644 testcases/kernel/syscalls/clock_settime/Makefile
 create mode 100644 testcases/kernel/syscalls/clock_settime/clock_settime01.c

runtest/syscalls +2 -0

index ac1d2d2cd..4cbc13209 100644
@@ -79,6 +79,8 @@ clock_nanosleep01 clock_nanosleep01
 clock_nanosleep02 clock_nanosleep02
 clock_nanosleep2_01 clock_nanosleep2_01
 
+clock_settime01 clock_settime01
+
 clone01 clone01
 clone02 clone02
 clone03 clone03

testcases/kernel/syscalls/clock_settime/.gitignore new file +1 -0

new file mode 100644
index 000000000..fcbb9fecc
@@ -0,0 +1 @@
+clock_settime01

testcases/kernel/syscalls/clock_settime/Makefile new file +8 -0

new file mode 100644
index 000000000..e6674a6b2
@@ -0,0 +1,8 @@
+# Copyright (c) 2018 - Linaro Limited. All rights reserved.
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+top_srcdir		?= ../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+
+include $(top_srcdir)/include/mk/generic_leaf_target.mk

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +22 -0

new file mode 100644
index 000000000..591e5c723
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for clock_settime(2) on different clock types
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+static struct timespec clock_realtime_saved;
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +70 -0

+	{				/* case 02: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -2,
+	 .exp_ret = -1,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 06: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 08: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 09: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 13: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+};

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +49 -0

+static void cleanup(void)
+{
+	/* restore realtime clock */
+
+	if (sys_clock_settime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_settime(2): could not set "
+				"current time back");
+}
+
+static void setup(void)
+{
+	if (sys_clock_gettime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_gettime(2): could not get "
+				"current time");
+}
+
+static void verify_clock_settime(unsigned int i)
+{
+	struct timespec spec, *specptr;
+
+	if (tc[i].replace == 0) {
+
+		/* add 1 sec to test clock */
+
+		specptr = &spec;
+		specptr->tv_sec = clock_realtime_saved.tv_sec + 1;
+		specptr->tv_nsec = clock_realtime_saved.tv_nsec;
+
+	} else {
+
+		/* bad pointer case */
+
+		if (tc[i].newtime.tv_sec == -2)
+			specptr = tst_get_bad_addr(cleanup);
+
+		/* use given values */
+
+		else {
+			specptr = &spec;
+			specptr->tv_sec = tc[i].newtime.tv_sec;
+			specptr->tv_nsec = tc[i].newtime.tv_nsec;
+		}
+	}
+
+	TEST(sys_clock_settime(tc[i].type, specptr));
+
+	if (tc[i].exp_ret == TST_RET) {
+
+		if (TST_RET >= 0)

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +14 -0

+		return;
+	}
+
+	tst_res(TFAIL | TTERRNO, "clock_settime(2): clock type %d failed",
+			tc[i].type);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test = verify_clock_settime,
+	.cleanup = cleanup,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+};

Signature · 5 lines

2.20.0.rc1


-- 
Mailing list info: https://lists.linux.it/listinfo/ltp

Hi!

Quoted 72 lines

---
 runtest/syscalls                              |   2 +
 .../kernel/syscalls/clock_settime/.gitignore  |   1 +
 .../kernel/syscalls/clock_settime/Makefile    |   8 +
 .../syscalls/clock_settime/clock_settime01.c  | 187 ++++++++++++++++++
 4 files changed, 198 insertions(+)
 create mode 100644 testcases/kernel/syscalls/clock_settime/.gitignore
 create mode 100644 testcases/kernel/syscalls/clock_settime/Makefile
 create mode 100644 testcases/kernel/syscalls/clock_settime/clock_settime01.c

runtest/syscalls +2 -0

index ac1d2d2cd..4cbc13209 100644
@@ -79,6 +79,8 @@ clock_nanosleep01 clock_nanosleep01
 clock_nanosleep02 clock_nanosleep02
 clock_nanosleep2_01 clock_nanosleep2_01
 
+clock_settime01 clock_settime01
+
 clone01 clone01
 clone02 clone02
 clone03 clone03

testcases/kernel/syscalls/clock_settime/.gitignore new file +1 -0

new file mode 100644
index 000000000..fcbb9fecc
@@ -0,0 +1 @@
+clock_settime01

testcases/kernel/syscalls/clock_settime/Makefile new file +8 -0

new file mode 100644
index 000000000..e6674a6b2
@@ -0,0 +1,8 @@
+# Copyright (c) 2018 - Linaro Limited. All rights reserved.
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+top_srcdir		?= ../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+
+include $(top_srcdir)/include/mk/generic_leaf_target.mk

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +22 -0

new file mode 100644
index 000000000..591e5c723
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for clock_settime(2) on different clock types
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+static struct timespec clock_realtime_saved;
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 32

Quoted 10 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +10 -0

+	int exp_ret;
+	int exp_err;
+	int replace;
+};
+
+struct test_case tc[] = {
+	{				/* case 01: REALTIME		      */
+	 .type = CLOCK_REALTIME,
+	 .exp_ret = 0,
+	 },

What about we separate the only positive case to a separate test, then we can also do more a few more sanity checks there. I would probably go for sequence of something as:

* get the realtime time
* increasing it by some value in seconds
* set the realtime time
* get the realtime time
* check that the value is aprox the first value increased by the value
* decrease by the value
* set it again
* check it again

That would cover both cases of setting time forward and backward and at the end we would end up with the correct time as a bonus.

Quoted 75 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +75 -0

+	{				/* case 02: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -2,
+	 .exp_ret = -1,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 06: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 08: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 09: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 13: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_ret = -1,
+	 .exp_err = EINVAL,
+	 },
+};
+
+static int sys_clock_settime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_settime, clk_id, tp);
+}

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 112

Quoted 5 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +5 -0

+
+static int sys_clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_gettime, clk_id, tp);
+}

Any reason why we avoid the clock_settime and clock_gettime libc functions here?

Quoted 56 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +55 -0

+static void cleanup(void)
+{
+	/* restore realtime clock */
+
+	if (sys_clock_settime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_settime(2): could not set "
+				"current time back");
+}
+
+static void setup(void)
+{
+	if (sys_clock_gettime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_gettime(2): could not get "
+				"current time");
+}
+
+static void verify_clock_settime(unsigned int i)
+{
+	struct timespec spec, *specptr;
+
+	if (tc[i].replace == 0) {
+
+		/* add 1 sec to test clock */
+
+		specptr = &spec;
+		specptr->tv_sec = clock_realtime_saved.tv_sec + 1;
+		specptr->tv_nsec = clock_realtime_saved.tv_nsec;
+
+	} else {
+
+		/* bad pointer case */
+
+		if (tc[i].newtime.tv_sec == -2)
+			specptr = tst_get_bad_addr(cleanup);
+
+		/* use given values */
+
+		else {
+			specptr = &spec;
+			specptr->tv_sec = tc[i].newtime.tv_sec;
+			specptr->tv_nsec = tc[i].newtime.tv_nsec;
+		}
+	}
+
+	TEST(sys_clock_settime(tc[i].type, specptr));
+
+	if (tc[i].exp_ret == TST_RET) {
+
+		if (TST_RET >= 0)
+			tst_res(TPASS, "clock_settime(2): worked as expected");
+
+		else {
+			if (tc[i].exp_err == TST_ERR)
+				tst_res(TPASS, "clock_settime(2): failed as "
+						"expected");

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 172

Quoted 4 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +4 -0

+			else
+				tst_res(TFAIL | TTERRNO, "clock_settime(2): "
+						"failed with different error");
+		}

LKML coding style prefers curly braces around both blocks if they are around one of them, but that's a minor one.

Quoted 19 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +14 -0

+		return;
+	}
+
+	tst_res(TFAIL | TTERRNO, "clock_settime(2): clock type %d failed",
+			tc[i].type);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test = verify_clock_settime,
+	.cleanup = cleanup,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+};

Signature · 1 line

2.20.0.rc1

Quoted 2 lines

Signature · 1 line

Mailing list info: https://lists.linux.it/listinfo/ltp

Fixes 343

clock_settime01 creates a new test, using new API, based on existing and older kernel/timers/clock_settime tests. It includes tests from files clock_settime02 and clock_settime03, which will be deleted in next commits.

Signed-off-by Rafael David Tinoco <[email protected]>

---

new file mode 100644
index 000000000..97d720fa2

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +19 -0

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic test for clock_settime(2) on REALTIME clock:
+ *
+ *      1) advance DELTA_SEC seconds
+ *      2) go backwards DELTA_SEC seconds
+ *
+ * Accept DELTA_PER deviation on both (specially going backwards).
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +13 -0

+}
+
+static void cleanup(void)
+{
+	clock_fixnow();
+}
+
+static void verify_clock_settime(void)
+{
+	static struct timespec begin, change, end, elapsed;
+
+	/* test 01: move forward */
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +16 -0

+		tst_res(TFAIL, "clock_settime(2): could not advance time");
+	else
+		tst_res(TPASS, "clock_settime(2): was able to advance time");
+
+	/* test 02: move backward */
+
+	if (clock_gettime(CLOCK_REALTIME, &begin) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime at the begin");
+
+	change.tv_sec = begin.tv_sec - DELTA_SEC;
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_res(TBROK | TTERRNO, "could not set realtime change");
+
+	if (clock_gettime(CLOCK_REALTIME, &end) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime after change");

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +8 -0

+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test_all = verify_clock_settime,
+	.cleanup = cleanup,
+	.needs_root = 1,
+};

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +128 -0

new file mode 100644
index 000000000..710f37219
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for errors of clock_settime(2) on different clock types.
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define DELTA_SEC 10
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+static struct timespec clock_realtime_saved;
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;
+	int exp_err;
+	int replace;
+};
+
+struct test_case tc[] = {
+	{				/* case 01: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -2,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 02: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 06: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 08: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 09: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+};
+
+/*
+ * Some tests may cause libc to segfault when passing bad arguments.
+ */
+static int sys_clock_settime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_settime, clk_id, tp);
+}
+
+static int sys_clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_gettime, clk_id, tp);
+}
+
+static void cleanup(void)
+{
+	/* restore realtime clock */
+
+	if (sys_clock_settime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_settime(2): could not set "
+				"current time back");
+}
+
+static void setup(void)
+{
+	if (sys_clock_gettime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_gettime(2): could not get "
+				"current time");
+}
+
+static void verify_clock_settime(unsigned int i)
+{
+	struct timespec spec, *specptr;
+
+	if (tc[i].replace == 0) {
+
+		/* add 1 sec to test clock */
+
+		specptr = &spec;
+		specptr->tv_sec = clock_realtime_saved.tv_sec + 1;
+		specptr->tv_nsec = clock_realtime_saved.tv_nsec;
+

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +33 -0

+			specptr = &spec;
+			specptr->tv_sec = tc[i].newtime.tv_sec;
+			specptr->tv_nsec = tc[i].newtime.tv_nsec;
+		}
+	}
+
+	TEST(sys_clock_settime(tc[i].type, specptr));
+
+	if (TST_RET == -1) {
+
+		if (tc[i].exp_err == TST_ERR) {
+
+			tst_res(TPASS, "clock_settime(2): failed as expected");
+
+		} else {
+			tst_res(TFAIL | TTERRNO, "clock_settime(2): "
+					"failed with different error");
+		}
+
+		return;
+	}
+
+	tst_res(TFAIL | TTERRNO, "clock_settime(2): clock type %d failed",
+			tc[i].type);
+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test = verify_clock_settime,
+	.cleanup = cleanup,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+};

Signature · 1 line

2.20.0.rc1

Hi!

Quoted 29 lines

new file mode 100644
index 000000000..97d720fa2

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +24 -0

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic test for clock_settime(2) on REALTIME clock:
+ *
+ *      1) advance DELTA_SEC seconds
+ *      2) go backwards DELTA_SEC seconds
+ *
+ * Accept DELTA_PER deviation on both (specially going backwards).
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define DELTA_SEC 10	/* 10 seconds delta    */
+#define DELTA_PER 0.1	/* 1 percent deviation */
+
+static struct timespec real_begin, mono_begin, mono_end;
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 29

Quoted 5 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +5 -0

+static void clock_elapsed(struct timespec *begin, struct timespec *end,
+		struct timespec *elapsed)
+{
+	elapsed->tv_sec = end->tv_sec - begin->tv_sec;
+	elapsed->tv_nsec = end->tv_nsec - begin->tv_nsec;

If you do this the elapsed may end up in non-normalized state, i.e. elapsed->tv_nsec may end up negative.

We do have all kinds of inline functions for conversion and arimetic in tst_timer.h so there is no point of rolling your own here.

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 32

Quoted 3 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +3 -0

+}
+
+static void clock_return(void)

^
I would have named this restore, but that is very minor.

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 39

Quoted 7 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +7 -0

+{
+	static struct timespec elapsed, adjust;
+
+	clock_elapsed(&mono_begin, &mono_end, &elapsed);
+
+	adjust.tv_sec = real_begin.tv_sec + elapsed.tv_sec;
+	adjust.tv_nsec = real_begin.tv_nsec + elapsed.tv_nsec;

We should normalize the addition here as well, i.e. carry over to seconds if the number of nanoseconds gets greater than 1s.

Ideally we should add a function to add two timespec structures into the tst_timer.h header (in a separate patch).

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 48

Quoted 9 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +8 -0

+	if (clock_settime(CLOCK_REALTIME, &adjust) != 0)
+		tst_res(TBROK | TTERRNO, "could restore realtime clock");
+}
+
+static void clock_fixnow(void)
+{
+	if (clock_gettime(CLOCK_MONOTONIC_RAW, &mono_end) != 0)
+		tst_res(TBROK | TTERRNO, "could not get elapsed time");

We should make sure here that both real_begin and mono_begin were set before we attempt to restore the system time. A restore_time flag se to 1 after we successfully read both will do.

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 61

Quoted 13 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +12 -0

+	clock_return();
+}
+
+static void setup(void)
+{
+	/* save initial monotonic time to restore it when needed */
+
+	if (clock_gettime(CLOCK_REALTIME, &real_begin) != 0)
+		tst_res(TBROK | TTERRNO, "could not get initial real time");
+
+	if (clock_gettime(CLOCK_MONOTONIC_RAW, &mono_begin) != 0)
+		tst_res(TBROK | TTERRNO, "couldn't get initial monotonic time");

^
This should have been tst_brk() doing tst_res() with TBROK does not make much sense.

Also we do have tst_safe_clocks.h, if you include that you can use SAFE_CLOCK_GETTIME() instead.

Overall the idea of restoring wall clock using monotonic timer is a good one, maybe we should even move this code to a library so that all tests that change wall clock would need just set restore_wallclock flag in the tst_test structure...

Quoted 14 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +13 -0

+}
+
+static void cleanup(void)
+{
+	clock_fixnow();
+}
+
+static void verify_clock_settime(void)
+{
+	static struct timespec begin, change, end, elapsed;
+
+	/* test 01: move forward */
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 84

Quoted 10 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +10 -0

+	if (clock_gettime(CLOCK_REALTIME, &begin) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime at the begin");
+
+	change.tv_sec = begin.tv_sec + DELTA_SEC;
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_res(TBROK | TTERRNO, "could not set realtime change");
+
+	if (clock_gettime(CLOCK_REALTIME, &end) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime after change");

Here as well.

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 88

Quoted 3 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +3 -0

+	clock_elapsed(&begin, &end, &elapsed);
+
+	if (elapsed.tv_sec < (float) (DELTA_SEC - (DELTA_SEC * DELTA_PER)))

It would be much easier to just use tst_timespec_diff_ms() and check that the result is in reasonable range. I.e. check lower bound as well.

Quoted 17 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +16 -0

+		tst_res(TFAIL, "clock_settime(2): could not advance time");
+	else
+		tst_res(TPASS, "clock_settime(2): was able to advance time");
+
+	/* test 02: move backward */
+
+	if (clock_gettime(CLOCK_REALTIME, &begin) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime at the begin");
+
+	change.tv_sec = begin.tv_sec - DELTA_SEC;
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_res(TBROK | TTERRNO, "could not set realtime change");
+
+	if (clock_gettime(CLOCK_REALTIME, &end) != 0)
+		tst_res(TBROK | TTERRNO, "could not get realtime after change");

testcases/kernel/syscalls/clock_settime/clock_settime01.c line 114

Quoted 10 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +10 -0

+
+	clock_elapsed(&begin, &end, &elapsed);
+
+	elapsed.tv_sec = ~elapsed.tv_sec;
+	elapsed.tv_nsec = ~elapsed.tv_nsec;
+
+	if (elapsed.tv_sec < (float) (DELTA_SEC - (DELTA_SEC * DELTA_PER)))
+		tst_res(TFAIL, "clock_settime(2): could not recede time");
+	else
+		tst_res(TPASS, "clock_settime(2): was able to recede time");

Here as well.

Quoted 143 lines

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +8 -0

+}
+
+static struct tst_test test = {
+	.setup = setup,
+	.test_all = verify_clock_settime,
+	.cleanup = cleanup,
+	.needs_root = 1,
+};

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +128 -0

new file mode 100644
index 000000000..710f37219
@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for errors of clock_settime(2) on different clock types.
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define DELTA_SEC 10
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+static struct timespec clock_realtime_saved;
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;
+	int exp_err;
+	int replace;
+};
+
+struct test_case tc[] = {
+	{				/* case 01: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -2,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 02: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 06: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 08: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 09: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+};
+
+/*
+ * Some tests may cause libc to segfault when passing bad arguments.
+ */
+static int sys_clock_settime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_settime, clk_id, tp);
+}
+
+static int sys_clock_gettime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_gettime, clk_id, tp);
+}
+
+static void cleanup(void)
+{
+	/* restore realtime clock */
+
+	if (sys_clock_settime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_settime(2): could not set "
+				"current time back");
+}
+
+static void setup(void)
+{
+	if (sys_clock_gettime(CLOCK_REALTIME, &clock_realtime_saved) < 0)
+		tst_res(TBROK | TTERRNO, "clock_gettime(2): could not get "
+				"current time");
+}
+
+static void verify_clock_settime(unsigned int i)
+{
+	struct timespec spec, *specptr;
+
+	if (tc[i].replace == 0) {
+
+		/* add 1 sec to test clock */
+
+		specptr = &spec;
+		specptr->tv_sec = clock_realtime_saved.tv_sec + 1;
+		specptr->tv_nsec = clock_realtime_saved.tv_nsec;
+

testcases/kernel/syscalls/clock_settime/clock_settime02.c line 138

Quoted 10 lines

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +10 -0

+	} else {
+
+		/* bad pointer case */
+
+		if (tc[i].newtime.tv_sec == -2)
+			specptr = tst_get_bad_addr(cleanup);
+
+		/* use given values */
+
+		else {

Still curly braces missing here, but that is minor.

And maybe we just need to turn the newtime into a pointer in the tcases structure. Then you can initialize global variable to current time + epsion and use pointer to it or even initialize it inline as:

static struct timespec valid_time;

struct test_case tc[] = {
	{
	 .type = CLOCK_REALTIME,
	 .exp_err = EFAULT,
	},
	{
	 .type = CLOCK_REALTIME;
	 .newtime = &valid_time;
	 .exp_err = EINVAL,
	{
	 .type = CLOCK_REALTIME,
	 .newtime = &(struct timespec){},
	 .exp_err = EINVAL,
	 .replace = 1,
	},
	...
};

And we can loop in the test setup and set NULL address to the result of tst_get_bad_addr() as well.

Quoted 29 lines

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +28 -0

+			specptr = &spec;
+			specptr->tv_sec = tc[i].newtime.tv_sec;
+			specptr->tv_nsec = tc[i].newtime.tv_nsec;
+		}
+	}
+
+	TEST(sys_clock_settime(tc[i].type, specptr));
+
+	if (TST_RET == -1) {
+
+		if (tc[i].exp_err == TST_ERR) {
+
+			tst_res(TPASS, "clock_settime(2): failed as expected");
+
+		} else {
+			tst_res(TFAIL | TTERRNO, "clock_settime(2): "
+					"failed with different error");
+		}
+
+		return;
+	}
+
+	tst_res(TFAIL | TTERRNO, "clock_settime(2): clock type %d failed",
+			tc[i].type);
+}
+
+static struct tst_test test = {
+	.setup = setup,

Quoted 8 lines

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +5 -0

+	.test = verify_clock_settime,
+	.cleanup = cleanup,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+};

Signature · 1 line

2.20.0.rc1

Some tests around clocks need to restore the correct date and time after the tests, including possible iterations, run.

This commit introduces a new field to tst_test called "restore_wallclock", which makes the test to save current realtime clock during setup phase, and, later, during cleanup, restore it to the appropriate time using a monotonic raw clock difference.

Signed-off-by Rafael David Tinoco <[email protected]>

---
 include/tst_test.h  |  1 +
 lib/tst_test.c      |  6 ++++++
 lib/tst_wallclock.c | 44 ++++++++++++++++++++++++++++++++++++++++++++

 3 files changed, 51 insertions(+)
 create mode 100644 lib/tst_wallclock.c

include/tst_test.h +1 -0

index 2ebf746eb..170bddc21 100644
@@ -131,6 +131,7 @@ struct tst_test {
 	int needs_rofs:1;
 	int child_needs_reinit:1;
 	int needs_devfs:1;
+	int restore_wallclock:1;
 	/*
 	 * If set the test function will be executed for all available
 	 * filesystems and the current filesytem type would be set in the

lib/tst_test.c +6 -0

index 661fbbfce..aa3d674f0 100644
@@ -868,6 +868,9 @@ static void do_setup(int argc, char *argv[])
 
 	if (tst_test->resource_files)
 		copy_resources();
+
+	if (tst_test->restore_wallclock)
+		tst_wallclock_save();
 }
 
 static void do_test_setup(void)

@@ -899,6 +902,9 @@ static void do_cleanup(void)
 		tst_sys_conf_restore(0);
 
 	cleanup_ipc();
+
+	if (tst_test->restore_wallclock)
+		tst_wallclock_restore();
 }
 
 static void run_tests(void)

lib/tst_wallclock.c new file +28 -0

new file mode 100644
index 000000000..ef08e1dba
@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+#include <errno.h>
+
+#define TST_NO_DEFAULT_MAIN
+
+#include "tst_test.h"
+#include "tst_timer.h"
+#include "tst_clocks.h"
+#include "lapi/posix_clocks.h"
+
+static struct timespec real_begin, mono_begin;
+
+void tst_wallclock_save(void)
+{
+	/* save initial monotonic time to restore it when needed */
+
+	if (tst_clock_gettime(CLOCK_REALTIME, &real_begin))
+		tst_brk(TBROK | TERRNO, "tst_clock_gettime() realtime failed");
+
+	if (tst_clock_gettime(CLOCK_MONOTONIC_RAW, &mono_begin))
+		tst_brk(TBROK | TERRNO, "tst_clock_gettime() monotonic failed");
+}
+

lib/tst_wallclock.c new file +5 -0

+	/* restore realtime clock based on monotonic delta */
+
+	if (tst_clock_settime(CLOCK_REALTIME, &adjust))
+		tst_brk(TBROK | TERRNO, "tst_clock_settime() realtime failed");
+}

Signature · 1 line

2.20.0.rc1

Fixes 343

clock_settime01 creates a new test, using new API, based on existing and older kernel/timers/clock_settime02 test. clock_settime02 creates another test based on older kernel/timers/clock_settime03 test. Both will be deleted in the next commits.

Signed-off-by Rafael David Tinoco <[email protected]>

---
 runtest/syscalls                              |   3 +
 .../kernel/syscalls/clock_settime/.gitignore  |   2 +
 .../kernel/syscalls/clock_settime/Makefile    |   8 +
 .../syscalls/clock_settime/clock_settime01.c  |  75 +++++++++
 .../syscalls/clock_settime/clock_settime02.c  | 150 ++++++++++++++++++
 5 files changed, 238 insertions(+)
 create mode 100644 testcases/kernel/syscalls/clock_settime/.gitignore
 create mode 100644 testcases/kernel/syscalls/clock_settime/Makefile
 create mode 100644 testcases/kernel/syscalls/clock_settime/clock_settime01.c
 create mode 100644 testcases/kernel/syscalls/clock_settime/clock_settime02.c

runtest/syscalls +3 -0

index 34b47f36b..dd03ad31a 100644
@@ -79,6 +79,9 @@ clock_nanosleep01 clock_nanosleep01
 clock_nanosleep02 clock_nanosleep02
 clock_nanosleep2_01 clock_nanosleep2_01
 
+clock_settime01 clock_settime01
+clock_settime02 clock_settime02
+
 clone01 clone01
 clone02 clone02
 clone03 clone03

testcases/kernel/syscalls/clock_settime/.gitignore new file +2 -0

new file mode 100644
index 000000000..281217550
@@ -0,0 +1,2 @@
+clock_settime01
+clock_settime02

testcases/kernel/syscalls/clock_settime/Makefile new file +8 -0

new file mode 100644
index 000000000..e6674a6b2
@@ -0,0 +1,8 @@
+# Copyright (c) 2018 - Linaro Limited. All rights reserved.
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+top_srcdir		?= ../../../..
+
+include $(top_srcdir)/include/mk/testcases.mk
+
+include $(top_srcdir)/include/mk/generic_leaf_target.mk

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +75 -0

new file mode 100644
index 000000000..6e0ee47c4
@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic test for clock_settime(2) on REALTIME clock:
+ *
+ *      1) advance DELTA_SEC seconds
+ *      2) go backwards DELTA_SEC seconds
+ *
+ * Restore wall clock at the end of test.
+ */
+
+#include "config.h"
+#include "tst_timer.h"
+#include "tst_safe_clocks.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+
+#define DELTA_SEC 10
+#define DELTA_SEC_US (long long) (DELTA_SEC * 1000000)
+#define DELTA_SEC_VAR_POS (long long) (DELTA_SEC_US * 1.10)
+#define DELTA_SEC_VAR_NEG (long long) (DELTA_SEC_US * 0.90)
+
+static void verify_clock_settime(void)
+{
+	long long elapsed;
+	struct timespec begin, change, end;
+
+	/* test 01: move forward */
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &begin);
+
+	change = tst_timespec_add_us(begin, DELTA_SEC_US);
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_brk(TBROK | TTERRNO, "could not set realtime change");
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &end);
+
+	elapsed = tst_timespec_diff_us(end, begin);
+
+	if (elapsed > DELTA_SEC_US && elapsed < DELTA_SEC_VAR_POS) {
+		tst_res(TPASS, "clock_settime(2): was able to advance time");
+	} else {
+		tst_res(TFAIL, "clock_settime(2): could not advance time");
+	}
+
+	/* test 02: move backward */
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &begin);
+
+	change = tst_timespec_rem_us(begin, DELTA_SEC_US);
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_brk(TBROK | TTERRNO, "could not set realtime change");
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &end);
+
+	elapsed = tst_timespec_diff_us(end, begin);
+
+	if (~(elapsed) > DELTA_SEC_VAR_NEG) {
+		tst_res(TPASS, "clock_settime(2): was able to recede time");
+	} else {
+		tst_res(TFAIL, "clock_settime(2): could not recede time");
+	}
+}
+
+static struct tst_test test = {
+	.test_all = verify_clock_settime,
+	.needs_root = 1,
+	.restore_wallclock = 1,
+};

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +16 -0

new file mode 100644
index 000000000..25fcbfe09
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for errors of clock_settime(2) on different clock types.
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+#include "tst_timer.h"
+#include "tst_safe_clocks.h"
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +13 -0

+static void verify_clock_settime(void)
+{
+	long long elapsed;
+	struct timespec begin, change, end;
+
+	/* test 01: move forward */
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &begin);
+
+	change = tst_timespec_add_us(begin, DELTA_SEC_US);
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)
+		tst_brk(TBROK | TTERRNO, "could not set realtime change");

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +4 -0

+	/* test 02: move backward */
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &begin);
+

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +7 -0

+}
+
+static struct tst_test test = {
+	.test_all = verify_clock_settime,
+	.needs_root = 1,
+	.restore_wallclock = 1,
+};

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +88 -0

new file mode 100644
index 000000000..25fcbfe09
@@ -0,0 +1,150 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2018 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for errors of clock_settime(2) on different clock types.
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+#include "tst_timer.h"
+#include "tst_safe_clocks.h"
+
+#define DELTA_SEC 10
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;
+	int exp_err;
+	int replace;
+};
+
+struct test_case tc[] = {
+	{				/* case 01: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -2,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 02: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 06: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 08: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 09: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+};
+
+/*

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +3 -0

+		}
+	}
 
 
 
+	TEST(sys_clock_settime(tc[i].type, specptr));

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +8 -0

+}
+
+static struct tst_test test = {
+	.test = verify_clock_settime,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+	.restore_wallclock = 1,
+};

Signature · 1 line

2.20.0.rc1

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +7 -0

+	/* test 02: move backward */
+
+	SAFE_CLOCK_GETTIME(CLOCK_REALTIME, &begin);
+
+	change = tst_timespec_sub_us(begin, DELTA_US);
+
+	if (clock_settime(CLOCK_REALTIME, &change) != 0)

testcases/kernel/syscalls/clock_settime/clock_settime01.c new file +7 -0

+}
+
+static struct tst_test test = {
+	.test_all = verify_clock_settime,
+	.needs_root = 1,
+	.restore_wallclock = 1,
+};

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +114 -0

new file mode 100644
index 000000000..09c9dc4a4
@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2019 Linaro Limited. All rights reserved.
+ * Author: Rafael David Tinoco <[email protected]>
+ */
+
+/*
+ * Basic tests for errors of clock_settime(2) on different clock types.
+ */
+
+#include "config.h"
+#include "tst_test.h"
+#include "lapi/syscalls.h"
+#include "tst_timer.h"
+#include "tst_safe_clocks.h"
+
+#define DELTA_SEC 10
+#define NSEC_PER_SEC (1000000000L)
+#define MAX_CLOCKS 16
+
+struct test_case {
+	clockid_t type;
+	struct timespec newtime;
+	int exp_err;
+	int replace;
+};
+
+struct test_case tc[] = {
+	{				/* case 01: REALTIME: timespec NULL   */
+	 .type = CLOCK_REALTIME,
+	 .exp_err = EFAULT,
+	 .replace = 1,
+	 },
+	{				/* case 02: REALTIME: tv_sec = -1     */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_sec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 03: REALTIME: tv_nsec = -1    */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = -1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 04: REALTIME: tv_nsec = 1s+1  */
+	 .type = CLOCK_REALTIME,
+	 .newtime.tv_nsec = NSEC_PER_SEC + 1,
+	 .exp_err = EINVAL,
+	 .replace = 1,
+	 },
+	{				/* case 05: MONOTONIC		      */
+	 .type = CLOCK_MONOTONIC,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 06: MAXCLOCK		      */
+	 .type = MAX_CLOCKS,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 07: MAXCLOCK+1		      */
+	 .type = MAX_CLOCKS + 1,
+	 .exp_err = EINVAL,
+	 },
+	/* Linux specific */
+	{				/* case 08: CLOCK_MONOTONIC_COARSE    */
+	 .type = CLOCK_MONOTONIC_COARSE,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 09: CLOCK_MONOTONIC_RAW       */
+	 .type = CLOCK_MONOTONIC_RAW,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 10: CLOCK_BOOTTIME	      */
+	 .type = CLOCK_BOOTTIME,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 11: CLOCK_PROCESS_CPUTIME_ID  */
+	 .type = CLOCK_PROCESS_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+	{				/* case 12: CLOCK_THREAD_CPUTIME_ID   */
+	 .type = CLOCK_THREAD_CPUTIME_ID,
+	 .exp_err = EINVAL,
+	 },
+};
+
+/*
+ * Some tests may cause libc to segfault when passing bad arguments.
+ */
+static int sys_clock_settime(clockid_t clk_id, struct timespec *tp)
+{
+	return tst_syscall(__NR_clock_settime, clk_id, tp);
+}
+
+static void verify_clock_settime(unsigned int i)
+{
+	struct timespec spec, *specptr;
+
+	specptr = &spec;
+
+	if (tc[i].replace == 0) {
+
+		SAFE_CLOCK_GETTIME(CLOCK_REALTIME, specptr);
+
+		/* add 1 sec to wall clock */
+		specptr->tv_sec += 1;
+
+	} else {
+
+		/* use given time spec */
+		*specptr = tc[i].newtime;
+	}
+
+	/* bad pointer case */

testcases/kernel/syscalls/clock_settime/clock_settime02.c new file +17 -0

+		}
+
+		return;
+	}
+
+	tst_res(TFAIL | TTERRNO, "clock_settime(2): clock %s passed "
+				 "unexpectedly, expected %s",
+				 clock_name(tc[i].type),
+				 tst_strerrno(tc[i].exp_err));
+}
+
+static struct tst_test test = {
+	.test = verify_clock_settime,
+	.tcnt = ARRAY_SIZE(tc),
+	.needs_root = 1,
+	.restore_wallclock = 1,
+};

Signature · 1 line

2.20.1

Hi!
Series pushed with some fine tunning (will respond to respective patches), thanks!

Signature · 2 lines

Cyril Hrubis
[email protected]

Fixes 343

clock_settime01 creates a new test, using new API, based on existing and older kernel/timers/clock_settime tests. It includes tests from files clock_settime02 and clock_settime03.

This commit deletes timers/clock_settime/* tests.

Signed-off-by Rafael David Tinoco <[email protected]>

Ping ? =o)

Hi!

Quoted 1 line

Ping ? =o)

We are in the middle of the pre-release freeze, I will get to you once the release is finalized.

On 8 Jan 2019, at 10:04, Rafael David Tinoco
<[email protected]> wrote:

Ping ? =o)

Quoted 12 lines

On 12 Dec 2018, at 18:37, Rafael David Tinoco
<[email protected]> wrote:

Fixes 343

clock_settime01 creates a new test, using new API, based on existing and older kernel/timers/clock_settime tests. It includes tests from files clock_settime02 and clock_settime03.

This commit deletes timers/clock_settime/* tests.

Signed-off-by Rafael David Tinoco <[email protected]>

I know you guys are catching up after the freeze, just making sure you don???t loose track of these 6 patches when you have time!

Expand tst_timer.h functionality by having a function to also remove given microseconds from a given timespec.

Signed-off-by Rafael David Tinoco <[email protected]>

---
 include/tst_timer.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

include/tst_timer.h +0 -0

index 577bc88ef..b1c9ceeba 100644

include/tst_timer.h +12 -0

+{
+	t.tv_sec -= us / 1000000;
+	t.tv_nsec -= (us % 1000000) * 1000;
+
+	if (t.tv_nsec < 0) {
+		t.tv_sec--;
+		t.tv_nsec += 1000000000;
+	}
+
+	return t;
+}
+
 /*
  * Returns difference between two timespec structures.
  */