From: Adhemerval Zanella <adhemerval.zanella@linaro.org>
To: libc-alpha@sourceware.org
Subject: [RFC v2] io: Return UNSUPPORTED if filesystem do not support 64 bit timestamps
Date: Thu, 11 Mar 2021 16:29:08 -0300 [thread overview]
Message-ID: <20210311192908.3124613-1-adhemerval.zanella@linaro.org> (raw)
In-Reply-To: <671a34b8-50c0-e5c6-db2e-727aeef2117b@linaro.org>
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 functions, 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
---
support/Makefile | 1 +
support/support.h | 5 ++
support/support_path_support_time64.c | 76 ++++++++++++++++++++++++++
sysdeps/unix/sysv/linux/tst-futimens.c | 8 ++-
sysdeps/unix/sysv/linux/tst-utime.c | 7 ++-
sysdeps/unix/sysv/linux/tst-utimes.c | 7 ++-
6 files changed, 101 insertions(+), 3 deletions(-)
create mode 100644 support/support_path_support_time64.c
diff --git a/support/Makefile b/support/Makefile
index 8d63fbd5da..5904cdd412 100644
--- 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 9cbc455720..2e477c9e7c 100644
--- 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
index 0000000000..74af7d4973
--- /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 8f48cfee63..785cd87557 100644
--- 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 6735421657..21e4e41dea 100644
--- 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 8c7b006a22..0f23e44897 100644
--- 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;
--
2.25.1
next prev parent reply other threads:[~2021-03-11 19:29 UTC|newest]
Thread overview: 6+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-03-11 12:35 [RFC] " Adhemerval Zanella
2021-03-11 15:08 ` Christoph Hellwig
2021-03-11 17:20 ` Adhemerval Zanella
2021-03-11 19:29 ` Adhemerval Zanella [this message]
2021-03-11 23:06 ` [RFC v2] " Carlos O'Donell
2021-03-11 15:32 ` [RFC] " Lukasz Majewski
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20210311192908.3124613-1-adhemerval.zanella@linaro.org \
--to=adhemerval.zanella@linaro.org \
--cc=libc-alpha@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).