y2038: linux: Provide __futimes64 implementation

This patch provides new __futimes64 explicit 64 bit function for setting file's
64 bit attributes for access and modification time (by specifying file
descriptor number).

Internally, the __utimensat64_helper function is used. This patch is necessary
for having architectures with __WORDSIZE == 32 Y2038 safe.

Moreover, a 32 bit version - __futimes has been refactored to internally use
__futimes64.

The __futimes is now supposed to be used on systems still supporting 32
bit time (__TIMESIZE != 64) - hence the necessary conversion of struct timeval
to 64 bit struct __timeval64.

The check if struct timevals' usec fields are in the range between 0 and 1000000
has been removed as Linux kernel performs it internally in the implementation
of utimensat (the conversion between struct __timeval64 and __timespec64 is not
relevant for this particular check).

Last but not least, checks for tvp{64} not being NULL have been preserved from
the original code as some legacy user space programs may rely on it.

Build tests:
./src/scripts/build-many-glibcs.py glibcs

Run-time tests:
- Run specific tests on ARM/x86 32bit systems (qemu):
  https://github.com/lmajewski/meta-y2038 and run tests:
  https://github.com/lmajewski/y2038-tests/commits/master

Above tests were performed with Y2038 redirection applied as well as without to
test the proper usage of both __futimes64 and __futimes.

2 files changed, 26 insertions, 19 deletions

diff --git a/include/time.h b/include/time.h
index 7737be1f7d..30c8e3d296 100644
--- a/include/time.h
+++ b/include/time.h
@@ -206,8 +206,11 @@ extern int __utimensat64_helper (int fd, const char *file,
 libc_hidden_proto (__utimensat64_helper);
 
 #if __TIMESIZE == 64
+# define __futimes64 __futimes
 # define __futimens64 __futimens
 #else
+extern int __futimes64 (int fd, const struct __timeval64 tvp64[2]);
+libc_hidden_proto (__futimes64);
 extern int __futimens64 (int fd, const struct __timespec64 tsp[2]);
 libc_hidden_proto (__futimens64);
 #endif
diff --git a/sysdeps/unix/sysv/linux/futimes.c b/sysdeps/unix/sysv/linux/futimes.c
index 4bea864470..21b41e4138 100644
--- a/sysdeps/unix/sysv/linux/futimes.c
+++ b/sysdeps/unix/sysv/linux/futimes.c
@@ -17,35 +17,39 @@
    <https://www.gnu.org/licenses/>.  */
 
 #include <errno.h>
-#include <sysdep.h>
-#include <string.h>
 #include <time.h>
-#include <utime.h>
-#include <sys/time.h>
-#include <_itoa.h>
-#include <fcntl.h>
-
 
 /* Change the access time of the file associated with FD to TVP[0] and
-   the modification time of FILE to TVP[1].
+   the modification time of FILE to TVP[1].  */
+int
+__futimes64 (int fd, const struct __timeval64 tvp64[2])
+{
+  /* The utimensat system call expects timespec not timeval.  */
+  struct __timespec64 ts64[2];
+  if (tvp64 != NULL)
+    {
+      ts64[0] = timeval64_to_timespec64 (tvp64[0]);
+      ts64[1] = timeval64_to_timespec64 (tvp64[1]);
+    }
+
+  return __utimensat64_helper (fd, NULL, tvp64 ? &ts64[0] : NULL, 0);
+}
+
+#if __TIMESIZE != 64
+libc_hidden_def (__futimes64)
 
-   Starting with 2.6.22 the Linux kernel has the utimensat syscall which
-   can be used to implement futimes.  */
 int
 __futimes (int fd, const struct timeval tvp[2])
 {
-  /* The utimensat system call expects timespec not timeval.  */
-  struct timespec ts[2];
+  struct __timeval64 tv64[2];
+
   if (tvp != NULL)
     {
-      if (tvp[0].tv_usec < 0 || tvp[0].tv_usec >= 1000000
-          || tvp[1].tv_usec < 0 || tvp[1].tv_usec >= 1000000)
-	return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL);
-
-      TIMEVAL_TO_TIMESPEC (&tvp[0], &ts[0]);
-      TIMEVAL_TO_TIMESPEC (&tvp[1], &ts[1]);
+      tv64[0] = valid_timeval_to_timeval64 (tvp[0]);
+      tv64[1] = valid_timeval_to_timeval64 (tvp[1]);
     }
 
-  return INLINE_SYSCALL (utimensat, 4, fd, NULL, tvp ? &ts : NULL, 0);
+  return __futimes64 (fd, tvp ? &tv64[0] : NULL);
 }
+#endif
 weak_alias (__futimes, futimes)