io: Return UNSUPPORTED if filesystem do not support 64 bit timestamps

Some Linux filesystems might not fully support 64 bit timestamps [1],
which make some Linux specific tests to fail when they check for the
functionality.

This patch adds a new libsupport function, support_path_support_time64,
that returns whether the target file supports or not 64 bit timestamps.
The support is checked by issuing a utimensat and verifying both the
last access and last modification time against a statx call.

The tests that might fail are also adjusted to check the file support
as well:

  $ dd if=/dev/zero of=loopbackfile.img bs=100M count=1
  1+0 records in
  1+0 records out
  104857600 bytes (105 MB, 100 MiB) copied, 0,0589568 s, 1,8 GB/s
  $ sudo losetup -fP loopbackfile.img
  $ mkfs.xfs loopbackfile.img
  meta-data=loopbackfile.img       isize=512    agcount=4, agsize=6400 blks
           =                       sectsz=512   attr=2, projid32bit=1
           =                       crc=1        finobt=1, sparse=1, rmapbt=0
           =                       reflink=1
  data     =                       bsize=4096   blocks=25600, imaxpct=25
           =                       sunit=0      swidth=0 blks
  naming   =version 2              bsize=4096   ascii-ci=0, ftype=1
  log      =internal log           bsize=4096   blocks=1368, version=2
           =                       sectsz=512   sunit=0 blks, lazy-count=1
  realtime =none                   extsz=4096   blocks=0, rtextents=0
  $ mkdir loopfs
  $ sudo mount -o loop /dev/loop0 loopfs/
  $ sudo chown -R azanella:azanella loopfs
  $ TMPDIR=loopfs/ ./testrun.sh misc/tst-utimes
  error: ../sysdeps/unix/sysv/linux/tst-utimes.c:55: File loopfs//utimesfECsK1 does not support 64-bit timestamps

[1] https://bugzilla.redhat.com/show_bug.cgi?id=1795576

diff --git a/support/Makefile b/support/Makefile
index 8d63fbd5da0cf90acda27f832d995ba31361f185..5904cdd412cf0bddf866ce5d2cd6fc1b168a4ee9 100644 (file)
--- a/support/Makefile
+++ b/support/Makefile
@@ -59,6 +59,7 @@ libsupport-routines = \
   support_format_hostent \
   support_format_netent \
   support_isolate_in_subprocess \
+  support_path_support_time64 \
   support_process_state \
   support_ptrace \
   support_openpty \

diff --git a/support/support.h b/support/support.h
index 9cbc45572054fd907e3806d954521bfbb570b9cb..2e477c9e7cf90cfe26880db2f91539e589ec8064 100644 (file)
--- a/support/support.h
+++ b/support/support.h
@@ -23,6 +23,7 @@
 #ifndef SUPPORT_H
 #define SUPPORT_H
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <sys/cdefs.h>
 /* For mode_t.  */
@@ -129,6 +130,10 @@ extern void support_copy_file (const char *from, const char *to);
 extern ssize_t support_copy_file_range (int, off64_t *, int, off64_t *,
                                        size_t, unsigned int);
 
+/* Return true is PATH supports 64-bit time_t interfaces for file
+   operations (such as fstatat or utimensat).  */
+extern bool support_path_support_time64 (const char *path);
+
 __END_DECLS
 
 #endif /* SUPPORT_H */

diff --git a/support/support_path_support_time64.c b/support/support_path_support_time64.c
new file mode 100644 (file)
index 0000000..74af7d4
--- /dev/null
+++ b/support/support_path_support_time64.c
@@ -0,0 +1,76 @@
+/* Check if path supports 64-bit time interfaces.
+   Copyright (C) 2021 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+#include <fcntl.h>
+#include <support/check.h>
+#include <support/support.h>
+#include <sys/stat.h>
+#ifdef __linux__
+#include <sysdep.h>
+#endif
+
+#ifdef __linux__
+static int
+utimesat_call (const char *path, const struct __timespec64 tsp[2])
+{
+# ifndef __NR_utimensat_time64
+#  define __NR_utimensat_time64 __NR_utimensat
+# endif
+  return INLINE_SYSCALL_CALL (utimensat_time64, AT_FDCWD, path, &tsp[0], 0);
+}
+#endif
+
+bool
+support_path_support_time64 (const char *path)
+{
+#ifdef __linux__
+  /* Obtain the original timestamps to restore at the end.  */
+  struct statx ostx;
+  TEST_VERIFY_EXIT (statx (AT_FDCWD, path, 0, STATX_BASIC_STATS, &ostx) == 0);
+
+  const struct __timespec64 tsp[] =
+  {
+    /* 1s and 2s after y2038 limit.  */
+    { 0x80000001ULL, 0 },
+    { 0x80000002ULL, 0 }
+  };
+  /* Return is kernel does not support __NR_utimensat_time64.  */
+  if (utimesat_call (path, tsp) == -1)
+    return false;
+
+  /* Verify if the last access and last modification time match the ones
+     obtained with statx.  */
+  struct statx stx;
+  TEST_VERIFY_EXIT (statx (AT_FDCWD, path, 0, STATX_BASIC_STATS, &stx) == 0);
+
+  bool support = stx.stx_atime.tv_sec == tsp[0].tv_sec
+                && stx.stx_mtime.tv_sec == tsp[1].tv_sec;
+
+  /* Reset to original timestamps.  */
+  const struct __timespec64 otsp[] =
+  {
+    { ostx.stx_atime.tv_sec, ostx.stx_atime.tv_nsec },
+    { ostx.stx_mtime.tv_sec, ostx.stx_mtime.tv_nsec },
+  };
+  TEST_VERIFY_EXIT (utimesat_call (path, otsp) == 0);
+
+  return support;
+#else
+  return true;
+#endif
+}

diff --git a/sysdeps/unix/sysv/linux/tst-futimens.c b/sysdeps/unix/sysv/linux/tst-futimens.c
index 8f48cfee635738f3974cd868b21711a3da6c6dd6..785cd87557620d439e43b8f2a3fc77b7de9c5a27 100644 (file)
--- a/sysdeps/unix/sysv/linux/tst-futimens.c
+++ b/sysdeps/unix/sysv/linux/tst-futimens.c
@@ -21,10 +21,12 @@
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <support/check.h>
+#include <support/support.h>
 #include <support/xunistd.h>
 #include <support/temp_file.h>
 
 static int temp_fd = -1;
+static char *testfile;
 
 /* struct timespec array with Y2038 threshold minus 2 and 1 seconds.  */
 const struct timespec t1[2] = { { 0x7FFFFFFE, 0 },  { 0x7FFFFFFF, 0 } };
@@ -39,13 +41,17 @@ const struct timespec t3[2] = { { 0x7FFFFFFE, 0 },  { 0x80000002ULL, 0 } };
 static void
 do_prepare (int argc, char *argv[])
 {
-  temp_fd = create_temp_file ("futimensat", NULL);
+  temp_fd = create_temp_file ("futimensat", &testfile);
   TEST_VERIFY_EXIT (temp_fd > 0);
 }
 
 static int
 test_futimens_helper (const struct timespec *ts)
 {
+  if (!support_path_support_time64 (testfile))
+    FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps",
+                     testfile);
+
   struct stat64 st;
   int result;
   time_t t;

diff --git a/sysdeps/unix/sysv/linux/tst-utime.c b/sysdeps/unix/sysv/linux/tst-utime.c
index 6735421657a9115fa11883ca0ebb087e9b2c7e89..21e4e41deaa4fc5a975270d9edbbced9f77554fb 100644 (file)
--- a/sysdeps/unix/sysv/linux/tst-utime.c
+++ b/sysdeps/unix/sysv/linux/tst-utime.c
@@ -23,11 +23,12 @@
 #include <sys/types.h>
 #include <utime.h>
 #include <support/check.h>
+#include <support/support.h>
 #include <support/xunistd.h>
 #include <support/temp_file.h>
 
 static int temp_fd = -1;
-char *testfile;
+static char *testfile;
 
 /* struct utimbuf with Y2038 threshold minus 2 and 1 seconds.  */
 const static struct utimbuf t1 = { 0x7FFFFFFE, 0x7FFFFFFF };
@@ -49,6 +50,10 @@ do_prepare (int argc, char *argv[])
 static int
 test_utime_helper (const struct utimbuf *ut)
 {
+  if (!support_path_support_time64 (testfile))
+    FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps",
+                     testfile);
+
   struct stat64 st;
   int result;
   time_t t;

diff --git a/sysdeps/unix/sysv/linux/tst-utimes.c b/sysdeps/unix/sysv/linux/tst-utimes.c
index 8c7b006a222f6ca23b41c8295ab610809c533b7d..0f23e4489716dbcf498dfd8ad842d1d44ef2ee31 100644 (file)
--- a/sysdeps/unix/sysv/linux/tst-utimes.c
+++ b/sysdeps/unix/sysv/linux/tst-utimes.c
@@ -22,11 +22,12 @@
 #include <sys/stat.h>
 #include <sys/time.h>
 #include <support/check.h>
+#include <support/support.h>
 #include <support/xunistd.h>
 #include <support/temp_file.h>
 
 static int temp_fd = -1;
-char *testfile;
+static char *testfile;
 
 /* struct timeval array with Y2038 threshold minus 2 and 1 seconds.  */
 const static struct timeval t1[2] = { { 0x7FFFFFFE, 0 },  { 0x7FFFFFFF, 0 } };
@@ -50,6 +51,10 @@ do_prepare (int argc, char *argv[])
 static int
 test_utime_helper (const struct timeval *tv)
 {
+  if (!support_path_support_time64 (testfile))
+    FAIL_UNSUPPORTED ("File %s does not support 64-bit timestamps",
+                     testfile);
+
   struct stat64 st;
   int result;
   time_t t;