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

Message ID 20210617115104.1359598-13-adhemerval.zanella@linaro.org
State New
Headers show
Series
  • More y2038 fixes
Related show

Commit Message

Adhemerval Zanella via Libc-alpha June 17, 2021, 11:50 a.m.
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(-)

-- 
2.30.2

Comments

Lukasz Majewski June 21, 2021, 7:44 a.m. | #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

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;
 }