linux: Only use 64-bit syscall if required for clock_nanosleep

For !__ASSUME_TIME64_SYSCALLS there is no need to issue a 64-bit syscall
if the provided timeout fits in a 32-bit one.  The 64-bit usage should
be rare since the timeout is a relative one.

Checked on i686-linux-gnu on a 4.15 kernel and on a 5.11 kernel
(with and without --enable-kernel=5.1) and on x86_64-linux-gnu.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

diff --git a/sysdeps/unix/sysv/linux/clock_nanosleep.c b/sysdeps/unix/sysv/linux/clock_nanosleep.c
index 007f1736cbe0f6b44aa51aa74d84085cf8a9eb1b..74e24075751f53d21c4b5dd89c5c5fcff6bc1970 100644 (file)
--- a/sysdeps/unix/sysv/linux/clock_nanosleep.c
+++ b/sysdeps/unix/sysv/linux/clock_nanosleep.c
@@ -27,8 +27,9 @@
 /* We can simply use the syscall.  The CPU clocks are not supported
    with this function.  */
 int
-__clock_nanosleep_time64 (clockid_t clock_id, int flags, const struct __timespec64 *req,
-                          struct __timespec64 *rem)
+__clock_nanosleep_time64 (clockid_t clock_id, int flags,
+                         const struct __timespec64 *req,
+                         struct __timespec64 *rem)
 {
   if (clock_id == CLOCK_THREAD_CPUTIME_ID)
     return EINVAL;
@@ -37,33 +38,36 @@ __clock_nanosleep_time64 (clockid_t clock_id, int flags, const struct __timespec
 
   /* If the call is interrupted by a signal handler or encounters an error,
      it returns a positive value similar to errno.  */
+
 #ifndef __NR_clock_nanosleep_time64
 # define __NR_clock_nanosleep_time64 __NR_clock_nanosleep
 #endif
-  int r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, clock_id,
-                                  flags, req, rem);
-
-#ifndef __ASSUME_TIME64_SYSCALLS
-  if (r == 0 || r != -ENOSYS)
-    return -r;
 
-  if (! in_time_t_range (req->tv_sec))
+  int r;
+#ifdef __ASSUME_TIME64_SYSCALLS
+  r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, clock_id, flags, req,
+                              rem);
+#else
+  if (!in_time_t_range (req->tv_sec))
     {
-      __set_errno (EOVERFLOW);
-      return -1;
+      r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep_time64, clock_id, flags,
+                                  req, rem);
+      if (r == -ENOSYS)
+       r = -EOVERFLOW;
     }
-
-  struct timespec tr32;
-  struct timespec ts32 = valid_timespec64_to_timespec (*req);
-  r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, clock_id, flags,
-                               &ts32, &tr32);
-  if (INTERNAL_SYSCALL_ERROR_P (r))
+  else
     {
-      if (r == -EINTR && rem != NULL && (flags & TIMER_ABSTIME) == 0)
-       *rem = valid_timespec_to_timespec64 (tr32);
+      struct timespec tr32;
+      struct timespec ts32 = valid_timespec64_to_timespec (*req);
+      r = INTERNAL_SYSCALL_CANCEL (clock_nanosleep, clock_id, flags, &ts32,
+                                  &tr32);
+      if (INTERNAL_SYSCALL_ERROR_P (r))
+       {
+         if (r == -EINTR && rem != NULL && (flags & TIMER_ABSTIME) == 0)
+           *rem = valid_timespec_to_timespec64 (tr32);
+       }
     }
-#endif /* __ASSUME_TIME64_SYSCALLS */
-
+#endif
   return -r;
 }
 

diff --git a/time/Makefile b/time/Makefile
index c84bd5d3ecee7817c57d4cd7f63407902e32f236..0bea84966c37805b65441884d1d37f0e0c48de5c 100644 (file)
--- a/time/Makefile
+++ b/time/Makefile
@@ -86,6 +86,15 @@ $(objpfx)tst-strftime2.out: $(gen-locales)
 $(objpfx)tst-strftime3.out: $(gen-locales)
 endif
 
+ifeq (yes,$(build-shared))
+librt = $(common-objpfx)rt/librt.so
+else
+librt = $(common-objpfx)rt/librt.a
+endif
+
+$(objpfx)tst-clock_nanosleep: $(librt)
+$(objpfx)tst-clock_nanosleep-time64: $(librt)
+
 tz-cflags = -DTZDIR='"$(zonedir)"' \
            -DTZDEFAULT='"$(localtime-file)"' \
            -DTZDEFRULES='"$(posixrules-file)"'

diff --git a/time/tst-clock_nanosleep.c b/time/tst-clock_nanosleep.c
index 47537435c1cee8c16aa981d31495659beea4c912..a5a7f9430a35364cbba3db5d38a11dadeeb5a431 100644 (file)
--- a/time/tst-clock_nanosleep.c
+++ b/time/tst-clock_nanosleep.c
@@ -20,38 +20,48 @@
 #include <unistd.h>
 #include <sys/time.h>
 #include <time.h>
-
+#include <intprops.h>
+#include <support/support.h>
+#include <support/check.h>
 
 /* Test that clock_nanosleep() does sleep.  */
-static int
-do_test (void)
+static void
+clock_nanosleep_test (void)
 {
   /* Current time.  */
   struct timeval tv1;
-  (void) gettimeofday (&tv1, NULL);
+  gettimeofday (&tv1, NULL);
 
-  struct timespec ts;
-  ts.tv_sec = 1;
-  ts.tv_nsec = 0;
+  struct timespec ts = { 1, 0 };
   TEMP_FAILURE_RETRY (clock_nanosleep (CLOCK_REALTIME, 0, &ts, &ts));
 
   /* At least one second must have passed.  */
   struct timeval tv2;
-  (void) gettimeofday (&tv2, NULL);
+  gettimeofday (&tv2, NULL);
 
   tv2.tv_sec -= tv1.tv_sec;
   tv2.tv_usec -= tv1.tv_usec;
   if (tv2.tv_usec < 0)
     --tv2.tv_sec;
 
-  if (tv2.tv_sec < 1)
-    {
-      puts ("clock_nanosleep didn't sleep long enough");
-      return 1;
-    }
+  TEST_VERIFY (tv2.tv_sec >= 1);
+}
+
+static void
+clock_nanosleep_large_timeout (void)
+{
+  support_create_timer (0, 100000000, false, NULL);
+  struct timespec ts = { TYPE_MAXIMUM (time_t), 0 };
+  int r = clock_nanosleep (CLOCK_REALTIME, 0, &ts, NULL);
+  TEST_VERIFY (r == EINTR || r == EOVERFLOW);
+}
 
+static int
+do_test (void)
+{
+  clock_nanosleep_test ();
+  clock_nanosleep_large_timeout ();
   return 0;
 }
 
-#define TEST_FUNCTION do_test ()
-#include "../test-skeleton.c"
+#include <support/test-driver.c>