mirror/glibc
2
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2024-11-27 03:41:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

y2038: linux: Provide __futimes64 implementation

Browse Source 
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.
This commit is contained in:
Lukasz Majewski 2020-02-16 09:32:42 +01:00
parent 7975f9a48a
commit f072671cf5
2 changed files with 26 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/time.h
View File

@ -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

42
sysdeps/unix/sysv/linux/futimes.c
View File

@ -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)