diff mbox series

[12/18] linux: Only use 64-bit syscall if required for timerfd_settime

Message ID 20210617115104.1359598-13-adhemerval.zanella@linaro.org
State Committed
Headers show
Series More y2038 fixes | expand

Checks

Context Check Description
dj/TryBot-apply_patch success Patch applied to master at the time it was sent

Commit Message

Adhemerval Zanella June 17, 2021, 11:50 a.m. UTC
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.
---
 sysdeps/unix/sysv/linux/Makefile          |  2 ++
 sysdeps/unix/sysv/linux/timerfd_settime.c | 25 ++++++++++---------
 sysdeps/unix/sysv/linux/tst-timerfd.c     | 29 +++++++++++++++++++++--
 3 files changed, 43 insertions(+), 13 deletions(-)

Comments

Lukasz Majewski June 21, 2021, 7:44 a.m. UTC | #1
On Thu, 17 Jun 2021 08:50:58 -0300
Adhemerval Zanella <adhemerval.zanella@linaro.org> wrote:

> 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.
> ---
>  sysdeps/unix/sysv/linux/Makefile          |  2 ++
>  sysdeps/unix/sysv/linux/timerfd_settime.c | 25 ++++++++++---------
>  sysdeps/unix/sysv/linux/tst-timerfd.c     | 29
> +++++++++++++++++++++-- 3 files changed, 43 insertions(+), 13
> deletions(-)
> 
> diff --git a/sysdeps/unix/sysv/linux/Makefile
> b/sysdeps/unix/sysv/linux/Makefile index 982755f980..2e5b5e1dc4 100644
> --- 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
> 0dd6fa026e..8f08133a73 100644 ---
> 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 is32bit_value = in_time_t_range (value->it_value.tv_sec);
> +  bool is32bit_interval = in_time_t_range
> (value->it_interval.tv_sec);
> +  if (!is32bit_value || !is32bit_interval)
>      {
> +      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 8828399119..27f1263ac6
> 100644 --- 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,28 @@ 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 } };
> +  TEST_COMPARE (timerfd_settime (fd, 0, &it, NULL), 0);
> +  uint64_t buf;
> +  TEST_COMPARE (read (fd, &buf, sizeof (buf)), -1);
> +  TEST_VERIFY (errno == EINTR || errno == EOVERFLOW);
> +}
> +
> +static int
> +do_test (void)
> +{
> +  timerfd_test ();
> +  timerfd_large_timeout ();
>    return 0;
>  }
>  

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


Best regards,

Lukasz Majewski

--

DENX Software Engineering GmbH,      Managing Director: Wolfgang Denk
HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany
Phone: (+49)-8142-66989-59 Fax: (+49)-8142-66989-80 Email: lukma@denx.de
diff mbox series

Patch

diff --git a/sysdeps/unix/sysv/linux/Makefile b/sysdeps/unix/sysv/linux/Makefile
index 982755f980..2e5b5e1dc4 100644
--- 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 0dd6fa026e..8f08133a73 100644
--- 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 is32bit_value = in_time_t_range (value->it_value.tv_sec);
+  bool is32bit_interval = in_time_t_range (value->it_interval.tv_sec);
+  if (!is32bit_value || !is32bit_interval)
     {
+      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 8828399119..27f1263ac6 100644
--- 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,28 @@  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 } };
+  TEST_COMPARE (timerfd_settime (fd, 0, &it, NULL), 0);
+  uint64_t buf;
+  TEST_COMPARE (read (fd, &buf, sizeof (buf)), -1);
+  TEST_VERIFY (errno == EINTR || errno == EOVERFLOW);
+}
+
+static int
+do_test (void)
+{
+  timerfd_test ();
+  timerfd_large_timeout ();
   return 0;
 }