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

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/Makefile b/sysdeps/unix/sysv/linux/Makefile
index fd440ef..bda0187 100644 (file)
--- a/sysdeps/unix/sysv/linux/Makefile
+++ b/sysdeps/unix/sysv/linux/Makefile
@@ -145,6 +145,8 @@ endif
 
 $(objpfx)tst-ppoll: $(librt)
 $(objpfx)tst-ppoll-time64: $(librt)
+$(objpfx)tst-timerfd: $(librt)
+$(objpfx)tst-timerfd-time64: $(librt)
 
 # Generate the list of SYS_* macros for the system calls (__NR_*
 # macros).  The file syscall-names.list contains all possible system

diff --git a/sysdeps/unix/sysv/linux/timerfd_settime.c b/sysdeps/unix/sysv/linux/timerfd_settime.c
index 0dd6fa0..0069e13 100644 (file)
--- a/sysdeps/unix/sysv/linux/timerfd_settime.c
+++ b/sysdeps/unix/sysv/linux/timerfd_settime.c
@@ -29,31 +29,34 @@ __timerfd_settime64 (int fd, int flags, const struct __itimerspec64 *value,
 #ifndef __NR_timerfd_settime64
 # define __NR_timerfd_settime64 __NR_timerfd_settime
 #endif
-  int ret = INLINE_SYSCALL_CALL (timerfd_settime64, fd, flags, value, ovalue);
-#ifndef __ASSUME_TIME64_SYSCALLS
-  if (ret == 0 || errno != ENOSYS)
-    return ret;
 
-  if (! in_time_t_range ((value->it_value).tv_sec)
-      || ! in_time_t_range ((value->it_interval).tv_sec))
+#ifdef __ASSUME_TIME64_SYSCALLS
+  return INLINE_SYSCALL_CALL (timerfd_settime64, fd, flags, value, ovalue);
+#else
+  bool need_time64 = !in_time_t_range (value->it_value.tv_sec)
+                    || !in_time_t_range (value->it_interval.tv_sec);
+  if (need_time64)
     {
+      int r = INLINE_SYSCALL_CALL (timerfd_settime64, fd, flags, value,
+                                  ovalue);
+      if (r == 0 || errno != ENOSYS)
+       return r;
       __set_errno (EOVERFLOW);
-      return -1;
+      return r;
     }
 
   struct itimerspec its32, oits32;
   its32.it_interval = valid_timespec64_to_timespec (value->it_interval);
   its32.it_value = valid_timespec64_to_timespec (value->it_value);
-
-  ret = INLINE_SYSCALL_CALL (timerfd_settime, fd, flags,
-                            &its32, ovalue ? &oits32 : NULL);
+  int ret = INLINE_SYSCALL_CALL (timerfd_settime, fd, flags,
+                                &its32, ovalue != NULL ? &oits32 : NULL);
   if (ret == 0 && ovalue != NULL)
     {
       ovalue->it_interval = valid_timespec_to_timespec64 (oits32.it_interval);
       ovalue->it_value = valid_timespec_to_timespec64 (oits32.it_value);
     }
-#endif
   return ret;
+#endif
 }
 
 #if __TIMESIZE != 64

diff --git a/sysdeps/unix/sysv/linux/tst-timerfd.c b/sysdeps/unix/sysv/linux/tst-timerfd.c
index 8828399..ac4b0c4 100644 (file)
--- a/sysdeps/unix/sysv/linux/tst-timerfd.c
+++ b/sysdeps/unix/sysv/linux/tst-timerfd.c
@@ -16,15 +16,18 @@
    License along with the GNU C Library; if not, see
    <https://www.gnu.org/licenses/>.  */
 
+#include <errno.h>
+#include <intprops.h>
 #include <time.h>
 #include <support/check.h>
+#include <support/support.h>
 #include <support/xunistd.h>
 #include <support/timespec.h>
 #include <sys/time.h>
 #include <sys/timerfd.h>
 
-static int
-do_test (void)
+static void
+timerfd_test (void)
 {
   struct itimerspec settings = { { 0, 0 }, { 2, 0 } };
   struct itimerspec val;
@@ -52,6 +55,33 @@ do_test (void)
   /* Check difference between timerfd_gettime calls.  */
   TEST_COMPARE (support_timespec_check_in_range
                 ((struct timespec) { 1, 0 }, val.it_value, 0.9, 1.0), 1);
+
+  xclose (fd);
+}
+
+static void
+timerfd_large_timeout (void)
+{
+  int fd = timerfd_create (CLOCK_REALTIME, 0);
+  TEST_VERIFY (fd != -1);
+  support_create_timer (0, 100000000, false, NULL);
+  struct itimerspec it = { { 0, 0 }, { TYPE_MAXIMUM (time_t), 0 } };
+  int r = timerfd_settime (fd, 0, &it, NULL);
+  if (r == 0)
+    {
+      uint64_t buf;
+      TEST_COMPARE (read (fd, &buf, sizeof (buf)), -1);
+      TEST_VERIFY (errno == EINTR);
+    }
+  else
+    TEST_COMPARE (errno, EOVERFLOW);
+}
+
+static int
+do_test (void)
+{
+  timerfd_test ();
+  timerfd_large_timeout ();
   return 0;
 }