[PATCH v4 0/3] y2038: Adding event_wait64()

[PATCH v4 0/3] y2038: Adding event_wait64()

[Florian Bezdeka]

Hi!

Just another y2038 related syscall, once again based on v1 sent out by
Song and rebased to current next with some code- and test-cleanups applied.

@Song:
This one was the last one in my inbox. Please make sure that all
following patches are based on next. IIRC there are 3 or 4 syscalls
remaining. We should take care of [1] as well. We need something in the CI
that tests the full implementation, i.e. including the glibc wrappers
(proper syscall delegation). According to the changelog [2] of recent 
glibc we should be able to use 64bit time_t.

[1]: https://gitlab.com/Xenomai/xenomai-hacker-space/-/issues/21
[2]: https://sourceware.org/pipermail/libc-alpha/2021-August/129718.html

Best regards,
Florian

Changes in v4:
  - Rework Patch 3. See commit message for details.
    Mostly test improvements.

Changes in v3:
  - None. git send-mail folded two different series together. Resending
    to allow maintainers to pick this series at once. Sorry for that.
 


Florian Bezdeka (1):
  y2038: testsuite/smokey/y2038: Adding tests for event_wait64

Song Chen (2):
  y2038: cobalt/posix/event: Adding event_wait64
  y2038: lib/cobalt/internal: dispatch event_wait

 include/cobalt/uapi/syscall.h          |  1 +
 kernel/cobalt/posix/event.c            | 34 ++++++++-
 kernel/cobalt/posix/event.h            | 12 ++++
 kernel/cobalt/posix/syscall32.c        |  9 +++
 kernel/cobalt/posix/syscall32.h        |  7 ++
 kernel/cobalt/trace/cobalt-posix.h     |  3 +-
 lib/cobalt/internal.c                  |  5 ++
 testsuite/smokey/y2038/syscall-tests.c | 95 +++++++++++++++++++++++---
 8 files changed, 153 insertions(+), 13 deletions(-)

-- 
2.30.2

[PATCH v4 1/3] y2038: cobalt/posix/event: Adding event_wait64

[Florian Bezdeka]

From: Song Chen <chensong_2000@189.cn>

Add a syscall specific for event_wait with 64bit time_t.

Signed-off-by: Song Chen <chensong_2000@189.cn>
[Florian: Tracing, reformatting/rebasing]
Signed-off-by: Florian Bezdeka <florian.bezdeka@siemens.com>
---
 include/cobalt/uapi/syscall.h      |  1 +
 kernel/cobalt/posix/event.c        | 34 +++++++++++++++++++++++++++---
 kernel/cobalt/posix/event.h        | 12 +++++++++++
 kernel/cobalt/posix/syscall32.c    |  9 ++++++++
 kernel/cobalt/posix/syscall32.h    |  7 ++++++
 kernel/cobalt/trace/cobalt-posix.h |  3 ++-
 6 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/include/cobalt/uapi/syscall.h b/include/cobalt/uapi/syscall.h
index e49110f5d..16edce15d 100644
--- a/include/cobalt/uapi/syscall.h
+++ b/include/cobalt/uapi/syscall.h
@@ -133,6 +133,7 @@
 #define sc_cobalt_mq_timedreceive64		110
 #define sc_cobalt_sigtimedwait64		111
 #define sc_cobalt_monitor_wait64		112
+#define sc_cobalt_event_wait64			113
 
 #define __NR_COBALT_SYSCALLS			128 /* Power of 2 */
 
diff --git a/kernel/cobalt/posix/event.c b/kernel/cobalt/posix/event.c
index 3712154f5..052c68605 100644
--- a/kernel/cobalt/posix/event.c
+++ b/kernel/cobalt/posix/event.c
@@ -20,6 +20,7 @@
 #include "clock.h"
 #include "event.h"
 #include <trace/events/cobalt-posix.h>
+#include <cobalt/kernel/time.h>
 
 /*
  * Cobalt event notification services
@@ -119,9 +120,9 @@ int __cobalt_event_wait(struct cobalt_event_shadow __user *u_event,
 	handle = cobalt_get_handle_from_user(&u_event->handle);
 
 	if (ts) {
-		if ((unsigned long)ts->tv_nsec >= ONE_BILLION)
+		if (!timespec64_valid(ts))
 			return -EINVAL;
-	
+
 		timeout = ts2ns(ts);
 		if (timeout) {
 			timeout++;
@@ -189,6 +190,24 @@ out:
 	return ret;
 }
 
+int __cobalt_event_wait64(struct cobalt_event_shadow __user *u_event,
+			  unsigned int bits,
+			  unsigned int __user *u_bits_r,
+			  int mode, const struct __kernel_timespec __user *u_ts)
+{
+	struct timespec64 ts, *tsp = NULL;
+	int ret;
+
+	if (u_ts) {
+		tsp = &ts;
+		ret = cobalt_get_timespec64(&ts, u_ts);
+		if (ret)
+			return ret;
+	}
+
+	return __cobalt_event_wait(u_event, bits, u_bits_r, mode, tsp);
+}
+
 COBALT_SYSCALL(event_wait, primary,
 	       (struct cobalt_event_shadow __user *u_event,
 		unsigned int bits,
@@ -208,6 +227,15 @@ COBALT_SYSCALL(event_wait, primary,
 	return __cobalt_event_wait(u_event, bits, u_bits_r, mode, tsp);
 }
 
+COBALT_SYSCALL(event_wait64, primary,
+	       (struct cobalt_event_shadow __user *u_event,
+		unsigned int bits,
+		unsigned int __user *u_bits_r,
+		int mode, const struct __kernel_timespec __user *u_ts))
+{
+	return __cobalt_event_wait64(u_event, bits, u_bits_r, mode, u_ts);
+}
+
 COBALT_SYSCALL(event_sync, current,
 	       (struct cobalt_event_shadow __user *u_event))
 {
@@ -278,7 +306,7 @@ COBALT_SYSCALL(event_destroy, current,
 	}
 
 	cobalt_event_reclaim(&event->resnode, s); /* drops lock */
-	
+
 	return 0;
 }
 
diff --git a/kernel/cobalt/posix/event.h b/kernel/cobalt/posix/event.h
index ef592f72c..919774c9a 100644
--- a/kernel/cobalt/posix/event.h
+++ b/kernel/cobalt/posix/event.h
@@ -41,6 +41,11 @@ int __cobalt_event_wait(struct cobalt_event_shadow __user *u_event,
 			unsigned int __user *u_bits_r,
 			int mode, const struct timespec64 *ts);
 
+int __cobalt_event_wait64(struct cobalt_event_shadow __user *u_event,
+			  unsigned int bits, unsigned int __user *u_bits_r,
+			  int mode,
+			  const struct __kernel_timespec __user *u_ts);
+
 COBALT_SYSCALL_DECL(event_init,
 		    (struct cobalt_event_shadow __user *u_evtsh,
 		     unsigned int value,
@@ -53,6 +58,13 @@ COBALT_SYSCALL_DECL(event_wait,
 		     int mode,
 		     const struct __user_old_timespec __user *u_ts));
 
+COBALT_SYSCALL_DECL(event_wait64,
+		    (struct cobalt_event_shadow __user *u_evtsh,
+		     unsigned int bits,
+		     unsigned int __user *u_bits_r,
+		     int mode,
+		     const struct __kernel_timespec __user *u_ts));
+
 COBALT_SYSCALL_DECL(event_sync,
 		    (struct cobalt_event_shadow __user *u_evtsh));
 
diff --git a/kernel/cobalt/posix/syscall32.c b/kernel/cobalt/posix/syscall32.c
index e6c9831b9..2d88fac83 100644
--- a/kernel/cobalt/posix/syscall32.c
+++ b/kernel/cobalt/posix/syscall32.c
@@ -795,6 +795,15 @@ COBALT_SYSCALL32emu(event_wait, primary,
 	return __cobalt_event_wait(u_event, bits, u_bits_r, mode, tsp);
 }
 
+COBALT_SYSCALL32emu(event_wait64, primary,
+		    (struct cobalt_event_shadow __user *u_event,
+		     unsigned int bits,
+		     unsigned int __user *u_bits_r,
+		     int mode, const struct __kernel_timespec __user *u_ts))
+{
+	return __cobalt_event_wait64(u_event, bits, u_bits_r, mode, u_ts);
+}
+
 COBALT_SYSCALL32emu(select, primary,
 		    (int nfds,
 		     compat_fd_set __user *u_rfds,
diff --git a/kernel/cobalt/posix/syscall32.h b/kernel/cobalt/posix/syscall32.h
index a2ef67808..3eb66571b 100644
--- a/kernel/cobalt/posix/syscall32.h
+++ b/kernel/cobalt/posix/syscall32.h
@@ -230,6 +230,13 @@ COBALT_SYSCALL32emu_DECL(event_wait,
 			  unsigned int __user *u_bits_r,
 			  int mode, const struct old_timespec32 __user *u_ts));
 
+COBALT_SYSCALL32emu_DECL(event_wait64,
+			 (struct cobalt_event_shadow __user *u_event,
+			  unsigned int bits,
+			  unsigned int __user *u_bits_r,
+			  int mode,
+			  const struct __kernel_timespec __user *u_ts));
+
 COBALT_SYSCALL32emu_DECL(select,
 			 (int nfds,
 			  compat_fd_set __user *u_rfds,
diff --git a/kernel/cobalt/trace/cobalt-posix.h b/kernel/cobalt/trace/cobalt-posix.h
index 221e25037..45e3cbcf7 100644
--- a/kernel/cobalt/trace/cobalt-posix.h
+++ b/kernel/cobalt/trace/cobalt-posix.h
@@ -165,7 +165,8 @@
 		__cobalt_symbolic_syscall(mq_timedsend64),  		\
 		__cobalt_symbolic_syscall(mq_timedreceive64),		\
 		__cobalt_symbolic_syscall(sigtimedwait64),		\
-		__cobalt_symbolic_syscall(monitor_wait64))
+		__cobalt_symbolic_syscall(monitor_wait64),		\
+		__cobalt_symbolic_syscall(event_wait64))
 
 DECLARE_EVENT_CLASS(cobalt_syscall_entry,
 	TP_PROTO(unsigned int nr),
-- 
2.30.2

[PATCH v4 2/3] y2038: lib/cobalt/internal: dispatch event_wait

[Florian Bezdeka]

From: Song Chen <chensong_2000@189.cn>

If sizeof time_t bigger than 4, which means glibc supports
64bit timespec, go to event_wait64.

otherwise, go to original event_wait.

Signed-off-by: Song Chen <chensong_2000@189.cn>
Signed-off-by: Florian Bezdeka <florian.bezdeka@siemens.com>
---
 lib/cobalt/internal.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/cobalt/internal.c b/lib/cobalt/internal.c
index 75933a830..bf1e940b7 100644
--- a/lib/cobalt/internal.c
+++ b/lib/cobalt/internal.c
@@ -483,8 +483,13 @@ int cobalt_event_wait(cobalt_event_t *event,
 
 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldtype);
 
+#ifdef __USE_TIME_BITS64
+	ret = XENOMAI_SYSCALL5(sc_cobalt_event_wait64,
+			       event, bits, bits_r, mode, timeout);
+#else
 	ret = XENOMAI_SYSCALL5(sc_cobalt_event_wait,
 			       event, bits, bits_r, mode, timeout);
+#endif
 
 	pthread_setcanceltype(oldtype, NULL);
 
-- 
2.30.2

[PATCH v4 3/3] y2038: testsuite/smokey/y2038: Adding tests for event_wait64

[Florian Bezdeka]

Based on the tests provided by Song with the following adjustments:
  - #includes cleaned up
  - making sure all resources used during tests have are cleaned up
  - Switched to CLOCK_MONOTONIC for time measurement
    __cobalt_event_wait sets the time mode to XN_ABSOLUTE, so we have to
    use CLOCK_MONOTONIC for comparisons
  - Adding a testcase for calling event_wait64 with a zero timeout,
    which should come back immediately with EWOULDBLOCK/EAGAIN

While at it: Adding a missing cobalt_monitor_destroy() in
             test_sc_cobalt_monitor_wait64

Signed-off-by: Florian Bezdeka <florian.bezdeka@siemens.com>
---
 testsuite/smokey/y2038/syscall-tests.c | 95 +++++++++++++++++++++++---
 1 file changed, 86 insertions(+), 9 deletions(-)

diff --git a/testsuite/smokey/y2038/syscall-tests.c b/testsuite/smokey/y2038/syscall-tests.c
index 839a50e07..8afedd7d1 100644
--- a/testsuite/smokey/y2038/syscall-tests.c
+++ b/testsuite/smokey/y2038/syscall-tests.c
@@ -10,17 +10,8 @@
  * Released under the terms of GPLv2.
  */
 #include <asm/xenomai/syscall.h>
-#include <cobalt/uapi/syscall.h>
 #include <smokey/smokey.h>
-#include <semaphore.h>
-#include <unistd.h>
-#include <stdint.h>
-#include <stdbool.h>
-#include <errno.h>
 #include <mqueue.h>
-#include <signal.h>
-#include <cobalt/uapi/monitor.h>
-#include <sys/cobalt.h>
 
 smokey_test_plugin(y2038, SMOKEY_NOARGS, "Validate correct y2038 support");
 
@@ -913,6 +904,88 @@ static int test_sc_cobalt_monitor_wait64(void)
 			       "Back at           : %lld sec %lld nsec\n",
 			       to.tv_sec, to.tv_nsec, t2.tv_sec, t2.tv_nsec);
 
+	if (!__T(ret, cobalt_monitor_destroy(&mon)))
+		return ret;
+
+	return 0;
+}
+
+static int test_sc_cobalt_event_wait64(void)
+{
+	int ret;
+	int sc_nr = sc_cobalt_event_wait64;
+	struct xn_timespec64 t1, t2;
+	struct timespec ts_nat;
+	struct cobalt_event_shadow evt;
+	unsigned int flags;
+
+	ret = cobalt_event_init(&evt, 0, COBALT_EVENT_FIFO);
+	if (ret)
+		return -errno;
+
+	/* Make sure we don't crash because of NULL pointers */
+	ret = XENOMAI_SYSCALL5(sc_nr, NULL, NULL, NULL, NULL, NULL);
+	if (ret == -ENOSYS) {
+		smokey_note("event_wait64: skipped. (no kernel support)");
+		return 0; // Not implemented, nothing to test, success
+	}
+	if (!smokey_assert(ret == -EINVAL))
+		return ret ? ret : -EINVAL;
+
+	/* Providing an invalid address has to deliver EFAULT */
+	ret = XENOMAI_SYSCALL5(sc_nr, &evt, 0x1, &flags, 0,
+			       (void *)0xdeadbeefUL);
+	if (!smokey_assert(ret == -EFAULT))
+		return ret ? ret : -EINVAL;
+
+	/* providing an invalid timeout has to deliver EINVAL */
+	t1.tv_sec = -1;
+	ret = XENOMAI_SYSCALL5(sc_nr, &evt, 0x1, &flags, 0, &t1);
+	if (!smokey_assert(ret == -EINVAL))
+		return ret ? ret : -EINVAL;
+
+	/*
+	 * providing a zero timeout,
+	 * should come back immediately with EWOULDBLOCK
+	 */
+	t1.tv_sec = 0;
+	t1.tv_nsec = 0;
+	ret = XENOMAI_SYSCALL5(sc_nr, &evt, 0x1, &flags, 0, &t1);
+	if (!smokey_assert(ret == -EWOULDBLOCK))
+		return ret ? ret : -EINVAL;
+
+	/*
+	 * Providing a valid timeout, waiting for it to time out and check
+	 * that we didn't come back to early.
+	 */
+	ret = clock_gettime(CLOCK_MONOTONIC, &ts_nat);
+	if (ret)
+		return -errno;
+
+	t1.tv_sec = ts_nat.tv_sec;
+	t1.tv_nsec = ts_nat.tv_nsec;
+	ts_add_ns(&t1, 500000);
+
+	ret = XENOMAI_SYSCALL5(sc_nr, &evt, 0x1, &flags, 0, &t1);
+	if (!smokey_assert(ret == -ETIMEDOUT))
+		return ret;
+
+	ret = clock_gettime(CLOCK_MONOTONIC, &ts_nat);
+	if (ret)
+		return -errno;
+
+	t2.tv_sec = ts_nat.tv_sec;
+	t2.tv_nsec = ts_nat.tv_nsec;
+
+	if (ts_less(&t2, &t1))
+		smokey_warning("event_wait64 returned too early!\n"
+			       "Expected wakeup at: %lld sec %lld nsec\n"
+			       "Back at           : %lld sec %lld nsec\n",
+			       t1.tv_sec, t1.tv_nsec, t2.tv_sec, t2.tv_nsec);
+
+	if (!__T(ret, cobalt_event_destroy(&evt)))
+		return ret;
+
 	return 0;
 }
 
@@ -964,5 +1037,9 @@ static int run_y2038(struct smokey_test *t, int argc, char *const argv[])
 	if (ret)
 		return ret;
 
+	ret = test_sc_cobalt_event_wait64();
+	if (ret)
+		return ret;
+
 	return 0;
 }
-- 
2.30.2

Re: [PATCH v4 0/3] y2038: Adding event_wait64()

[Jan Kiszka]

On 12.08.21 09:09, Florian Bezdeka wrote:
> Hi!
> 
> Just another y2038 related syscall, once again based on v1 sent out by
> Song and rebased to current next with some code- and test-cleanups applied.
> 
> @Song:
> This one was the last one in my inbox. Please make sure that all
> following patches are based on next. IIRC there are 3 or 4 syscalls
> remaining. We should take care of [1] as well. We need something in the CI
> that tests the full implementation, i.e. including the glibc wrappers
> (proper syscall delegation). According to the changelog [2] of recent 
> glibc we should be able to use 64bit time_t.
> 
> [1]: https://gitlab.com/Xenomai/xenomai-hacker-space/-/issues/21
> [2]: https://sourceware.org/pipermail/libc-alpha/2021-August/129718.html
> 
> Best regards,
> Florian
> 
> Changes in v4:
>   - Rework Patch 3. See commit message for details.
>     Mostly test improvements.
> 
> Changes in v3:
>   - None. git send-mail folded two different series together. Resending
>     to allow maintainers to pick this series at once. Sorry for that.
>  
> 
> 
> Florian Bezdeka (1):
>   y2038: testsuite/smokey/y2038: Adding tests for event_wait64
> 
> Song Chen (2):
>   y2038: cobalt/posix/event: Adding event_wait64
>   y2038: lib/cobalt/internal: dispatch event_wait
> 
>  include/cobalt/uapi/syscall.h          |  1 +
>  kernel/cobalt/posix/event.c            | 34 ++++++++-
>  kernel/cobalt/posix/event.h            | 12 ++++
>  kernel/cobalt/posix/syscall32.c        |  9 +++
>  kernel/cobalt/posix/syscall32.h        |  7 ++
>  kernel/cobalt/trace/cobalt-posix.h     |  3 +-
>  lib/cobalt/internal.c                  |  5 ++
>  testsuite/smokey/y2038/syscall-tests.c | 95 +++++++++++++++++++++++---
>  8 files changed, 153 insertions(+), 13 deletions(-)
> 

Thanks, applied.

Jan

-- 
Siemens AG, T RDA IOT
Corporate Competence Center Embedded Linux