Note that the following code assumes that STDIN_FILENO,
STDOUT_FILENO, STDERR_FILENO are the three lowest file
decsriptor numbers, in this order. */
- struct stat64 st;
- if (__builtin_expect (nullfd != fd, 0)
- || __builtin_expect (__fstat64 (fd, &st), 0) != 0
- || __builtin_expect (S_ISCHR (st.st_mode), 1) == 0
+ struct __stat64_t64 st;
+ if (__glibc_unlikely (nullfd != fd)
+ || __glibc_likely (__fstat64_time64 (fd, &st) != 0)
+ || __glibc_unlikely (S_ISCHR (st.st_mode) == 0)
|| st.st_rdev != dev)
/* We cannot even give an error message here since it would
run into the same problems. */
{
/* We failed to open machine dependent library. Let's
test whether there is any directory at all. */
- struct stat64 st;
+ struct __stat64_t64 st;
buf[buflen - namelen - 1] = '\0';
- if (__stat64 (buf, &st) != 0
+ if (__stat64_time64 (buf, &st) != 0
|| ! S_ISDIR (st.st_mode))
/* The directory does not exist or it is no directory. */
this_dir->status[cnt] = nonexisting;
/* This is an extra security effort to make sure nobody can
preload broken shared objects which are in the trusted
directories and so exploit the bugs. */
- struct stat64 st;
+ struct __stat64_t64 st;
- if (__fstat64 (fd, &st) != 0
+ if (__fstat64_time64 (fd, &st) != 0
|| (st.st_mode & S_ISUID) == 0)
{
/* The shared object cannot be tested for being SUID
_dl_sysdep_read_whole_file (const char *file, size_t *sizep, int prot)
{
void *result = MAP_FAILED;
- struct stat64 st;
+ struct __stat64_t64 st;
int fd = __open64_nocancel (file, O_RDONLY | O_CLOEXEC);
if (fd >= 0)
{
- if (__fstat64 (fd, &st) >= 0)
+ if (__fstat64_time64 (fd, &st) >= 0)
{
*sizep = st.st_size;
{
char *filename;
int fd;
- struct stat64 st;
+ struct __stat64_t64 st;
const ElfW(Phdr) *ph;
ElfW(Addr) mapstart = ~((ElfW(Addr)) 0);
ElfW(Addr) mapend = 0;
return;
}
- if (__fstat64 (fd, &st) < 0 || !S_ISREG (st.st_mode))
+ if (__fstat64_time64 (fd, &st) < 0 || !S_ISREG (st.st_mode))
{
/* Not stat'able or not a regular file => don't use it. */
errstr = "%s: cannot stat file: %s\n";
__gconv_load_cache (void)
{
int fd;
- struct stat64 st;
+ struct __stat64_t64 st;
struct gconvcache_header *header;
/* We cannot use the cache if the GCONV_PATH environment variable is
return -1;
/* Get information about the file. */
- if (__builtin_expect (__fstat64 (fd, &st), 0) < 0
+ if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0)
/* We do not have to start looking at the file if it cannot contain
at least the cache header. */
|| (size_t) st.st_size < sizeof (struct gconvcache_header))
const struct dirent64 **b)
__attribute_pure__;
extern DIR *__alloc_dir (int fd, bool close_fd, int flags,
- const struct stat64 *statp)
+ const struct __stat64_t64 *statp)
__nonnull (4) attribute_hidden;
extern __typeof (rewinddir) __rewinddir;
extern __typeof (seekdir) __seekdir;
off64_t size;
ino64_t ino;
- struct timespec mtime;
- struct timespec ctime;
+ struct __timespec64 mtime;
+ struct __timespec64 ctime;
};
/* Returns true if *LEFT and *RIGHT describe the same version of the
/* Extract file change information to *FILE from the stat buffer
*ST. */
void __file_change_detection_for_stat (struct file_change_detection *file,
- const struct stat64 *st);
+ const struct __stat64_t64 *st);
/* Writes file change information for PATH to *FILE. Returns true on
success. For benign errors, *FILE is cleared, and true is
static FILE *
iruserfopen (const char *file, uid_t okuser)
{
- struct stat64 st;
+ struct __stat64_t64 st;
char *cp = NULL;
FILE *res = NULL;
/* If not a regular file, if owned by someone other than user or
root, if writeable by anyone but the owner, or if hardlinked
anywhere, quit. */
- if (__lstat64 (file, &st))
+ if (__lstat64_time64 (file, &st))
cp = _("lstat failed");
else if (!S_ISREG (st.st_mode))
cp = _("not regular file");
res = fopen (file, "rce");
if (!res)
cp = _("cannot open");
- else if (__fstat64 (fileno (res), &st) < 0)
+ else if (__fstat64_time64 (fileno (res), &st) < 0)
cp = _("fstat failed");
else if (st.st_uid && st.st_uid != okuser)
cp = _("bad owner");
int fd = -1;
size_t size;
#ifdef _LIBC
- struct stat64 st;
+ struct __stat64_t64 st;
#else
struct stat st;
#endif
/* We must know about the size of the file. */
if (
#ifdef _LIBC
- __builtin_expect (__fstat64 (fd, &st) != 0, 0)
+ __glibc_unlikely (__fstat64_time64 (fd, &st) != 0)
#else
__builtin_expect (fstat (fd, &st) != 0, 0)
#endif
tst-posix_fallocate tst-posix_fallocate64 \
tst-fts tst-fts-lfs tst-open-tmpfile \
tst-copy_file_range tst-getcwd-abspath tst-lockf \
- tst-ftw-lnk tst-file_change_detection tst-lchmod \
+ tst-ftw-lnk tst-lchmod \
tst-ftw-bz26353 tst-stat tst-stat-lfs \
tst-utime \
tst-utimes \
tst-utimes-time64 \
# Likewise for statx, but we do not need static linking here.
-tests-internal += tst-statx
+tests-internal += tst-statx tst-file_change_detection
tests-static += tst-statx
ifeq ($(run-built-tests),yes)
void
__file_change_detection_for_stat (struct file_change_detection *file,
- const struct stat64 *st)
+ const struct __stat64_t64 *st)
{
if (S_ISDIR (st->st_mode))
/* Treat as empty file. */
__file_change_detection_for_path (struct file_change_detection *file,
const char *path)
{
- struct stat64 st;
- if (__stat64 (path, &st) != 0)
+ struct __stat64_t64 st;
+ if (__stat64_time64 (path, &st) != 0)
switch (errno)
{
case EACCES:
}
else
{
- struct stat64 st;
- if (__fstat64 (__fileno (fp), &st) != 0)
+ struct __stat64_t64 st;
+ if (__fstat64_time64 (__fileno (fp), &st) != 0)
/* If we already have a file descriptor, all errors are fatal. */
return false;
else
get_current_dir_name (void)
{
char *pwd;
- struct stat64 dotstat, pwdstat;
+ struct __stat64_t64 dotstat, pwdstat;
pwd = getenv ("PWD");
if (pwd != NULL
- && __stat64 (".", &dotstat) == 0
- && __stat64 (pwd, &pwdstat) == 0
+ && __stat64_time64 (".", &dotstat) == 0
+ && __stat64_time64 (pwd, &pwdstat) == 0
&& pwdstat.st_dev == dotstat.st_dev
&& pwdstat.st_ino == dotstat.st_ino)
/* The PWD value is correct. Use it. */
{
size_t size;
char *p;
- struct stat64 st;
+ struct __stat64_t64 st;
size = BUFSIZ;
if (fp->_fileno >= 0 && __builtin_expect (_IO_SYSSTAT (fp, &st), 0) >= 0)
static int
mmap_remap_check (FILE *fp)
{
- struct stat64 st;
+ struct __stat64_t64 st;
if (_IO_SYSSTAT (fp, &st) == 0
&& S_ISREG (st.st_mode) && st.st_size != 0
file descriptors are for mmap-able objects and on 32-bit
machines we don't want to map files which are too large since
this would require too much virtual memory. */
- struct stat64 st;
+ struct __stat64_t64 st;
if (_IO_SYSSTAT (fp, &st) == 0
&& S_ISREG (st.st_mode) && st.st_size != 0
break;
case _IO_seek_end:
{
- struct stat64 st;
+ struct __stat64_t64 st;
if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
{
offset += st.st_size;
int
_IO_file_stat (FILE *fp, void *st)
{
- return __fstat64 (fp->_fileno, (struct stat64 *) st);
+ return __fstat64_time64 (fp->_fileno, (struct __stat64_t64 *) st);
}
libc_hidden_def (_IO_file_stat)
break;
case _IO_seek_end:
{
- struct stat64 st;
+ struct __stat64_t64 st;
if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
{
offset += st.st_size;
break;
case _IO_seek_end:
{
- struct stat64 st;
+ struct __stat64_t64 st;
if (_IO_SYSSTAT (fp, &st) == 0 && S_ISREG (st.st_mode))
{
offset += st.st_size;
ARCHMAPPED points to this; if mapping the archive header failed,
then headmap.ptr is null. */
static struct archmapped headmap;
-static struct stat64 archive_stat; /* stat of archive when header mapped. */
+static struct __stat64_t64 archive_stat; /* stat of archive when header mapped. */
/* Record of locales that we have already loaded from the archive. */
struct locale_in_archive
/* Cannot open the archive, for whatever reason. */
return NULL;
- if (__fstat64 (fd, &archive_stat) == -1)
+ if (__fstat64_time64 (fd, &archive_stat) == -1)
{
/* stat failed, very strange. */
close_and_out:
/* Open the file if it hasn't happened yet. */
if (fd == -1)
{
- struct stat64 st;
+ struct __stat64_t64 st;
fd = __open_nocancel (archfname,
O_RDONLY|O_LARGEFILE|O_CLOEXEC);
if (fd == -1)
/* Now verify we think this is really the same archive file
we opened before. If it has been changed we cannot trust
the header we read previously. */
- if (__fstat64 (fd, &st) < 0
+ if (__fstat64_time64 (fd, &st) < 0
|| st.st_size != archive_stat.st_size
|| st.st_mtime != archive_stat.st_mtime
|| st.st_dev != archive_stat.st_dev
{
int fd;
void *filedata;
- struct stat64 st;
+ struct __stat64_t64 st;
struct __locale_data *newdata;
int save_err;
int alloc = ld_mapped;
/* Cannot open the file. */
return;
- if (__builtin_expect (__fstat64 (fd, &st), 0) < 0)
+ if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0))
{
puntfd:
__close_nocancel_nostatus (fd);
if (__builtin_expect (fd, 0) < 0)
return;
- if (__builtin_expect (__fstat64 (fd, &st), 0) < 0)
+ if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0))
goto puntfd;
}
if (__glibc_unlikely (n == keylen))
{
- struct stat64 st;
- if (__builtin_expect (__fstat64 (mapfd, &st) != 0, 0)
+ struct __stat64_t64 st;
+ if (__glibc_unlikely (__fstat64_time64 (mapfd, &st) != 0)
|| __builtin_expect (st.st_size < sizeof (struct database_pers_head),
0))
goto out_close;
nss_action_list *result,
enum nss_database database_index)
{
- struct stat64 str;
+ struct __stat64_t64 str;
/* Acquire MO is needed because the thread that sets reload_disabled
may have loaded the configuration first, so synchronize with the
errors here are very unlikely, but the chance that we're entering
a container is also very unlikely, so we err on the side of both
very unlikely things not happening at the same time. */
- if (__stat64 ("/", &str) != 0
+ if (__stat64_time64 ("/", &str) != 0
|| (local->root_ino != 0
&& (str.st_ino != local->root_ino
|| str.st_dev != local->root_dev)))
static inline bool
_dl_get_file_id (int fd, struct r_file_id *id)
{
- struct stat64 st;
+ struct __stat64_t64 st;
- if (__glibc_unlikely (__fstat64 (fd, &st) < 0))
+ if (__glibc_unlikely (__fstat64_time64 (fd, &st) < 0))
return false;
id->dev = st.st_dev;
int
euidaccess (const char *path, int mode)
{
- struct stat64 stats;
+ struct __stat64_t64 stats;
int granted;
#ifdef _LIBC
return access (path, mode);
#endif
- if (__stat64 (path, &stats))
+ if (__stat64_time64 (path, &stats))
return -1;
mode &= (X_OK | W_OK | R_OK); /* Clear any bogus bits. */
/* Last modification time. */
#ifdef _STATBUF_ST_NSEC
-static struct timespec gaiconf_mtime;
+static struct __timespec64 gaiconf_mtime;
static inline void
-save_gaiconf_mtime (const struct stat64 *st)
+save_gaiconf_mtime (const struct __stat64_t64 *st)
{
gaiconf_mtime = st->st_mtim;
}
static inline bool
-check_gaiconf_mtime (const struct stat64 *st)
+check_gaiconf_mtime (const struct __stat64_t64 *st)
{
return (st->st_mtim.tv_sec == gaiconf_mtime.tv_sec
&& st->st_mtim.tv_nsec == gaiconf_mtime.tv_nsec);
static time_t gaiconf_mtime;
static inline void
-save_gaiconf_mtime (const struct stat64 *st)
+save_gaiconf_mtime (const struct __stat64_t64 *st)
{
gaiconf_mtime = st->st_mtime;
}
static inline bool
-check_gaiconf_mtime (const struct stat64 *st)
+check_gaiconf_mtime (const struct __stat64_t64 *st)
{
return st->st_mtime == gaiconf_mtime;
}
FILE *fp = fopen (GAICONF_FNAME, "rce");
if (fp != NULL)
{
- struct stat64 st;
- if (__fstat64 (fileno (fp), &st) != 0)
+ struct __stat64_t64 st;
+ if (__fstat64_time64 (fileno (fp), &st) != 0)
{
fclose (fp);
goto no_file;
static void
gaiconf_reload (void)
{
- struct stat64 st;
- if (__stat64 (GAICONF_FNAME, &st) != 0
+ struct __stat64_t64 st;
+ if (__stat64_time64 (GAICONF_FNAME, &st) != 0
|| !check_gaiconf_mtime (&st))
gaiconf_init ();
}
ino_t rootino, thisino;
char *dir;
register char *dirp;
- struct stat64 st;
+ struct __stat64_t64 st;
size_t allocated = size;
size_t used;
dirp = dir + allocated;
*--dirp = '\0';
- if (__lstat64 (".", &st) < 0)
+ if (__lstat64_time64 (".", &st) < 0)
goto lose;
thisdev = st.st_dev;
thisino = st.st_ino;
- if (__lstat64 ("/", &st) < 0)
+ if (__lstat64_time64 ("/", &st) < 0)
goto lose;
rootdev = st.st_dev;
rootino = st.st_ino;
if (fd < 0)
goto lose;
fd_needs_closing = true;
- parent_status = __fstat64 (fd, &st);
+ parent_status = __fstat64_time64 (fd, &st);
#else
dotlist[dotlen++] = '.';
dotlist[dotlen++] = '.';
dotlist[dotlen] = '\0';
- parent_status = __lstat64 (dotlist, &st);
+ parent_status = __lstat64_time64 (dotlist, &st);
#endif
if (parent_status != 0)
goto lose;
{
int entry_status;
#if HAVE_OPENAT_SUPPORT
- entry_status = __fstatat64 (fd, d->d_name, &st, AT_SYMLINK_NOFOLLOW);
+ entry_status = __fstatat64_time64 (fd, d->d_name, &st,
+ AT_SYMLINK_NOFOLLOW);
#else
/* Compute size needed for this file name, or for the file
name ".." in the same directory, whichever is larger.
}
memcpy (dotlist + dotlen, d->d_name, _D_ALLOC_NAMLEN (d));
- entry_status = __lstat64 (dotlist, &st);
+ entry_status = __lstat64_time64 (dotlist, &st);
#endif
/* We don't fail here if we cannot stat() a directory entry.
This can happen when (network) file systems fail. If this
#ifdef _POSIX_ASYNC_IO
{
/* AIO is only allowed on regular files and block devices. */
- struct stat64 st;
+ struct __stat64_t64 st;
- if (__stat64 (path, &st) < 0
+ if (__stat64_time64 (path, &st) < 0
|| (! S_ISREG (st.st_mode) && ! S_ISBLK (st.st_mode)))
return -1;
else
"/POSIX_V6_", sizeof ("/POSIX_V6_") - 1),
spec, speclen + 1);
- struct stat64 st;
- long int ret = __stat64 (name, &st) >= 0 ? 1 : -1;
+ struct __stat64_t64 st;
+ long int ret = __stat64_time64 (name, &st) >= 0 ? 1 : -1;
__set_errno (save_errno);
return ret;
#include <time.h>
#if _LIBC
-# define struct_stat64 struct stat64
+# define struct_stat64 struct __stat64_t64
# define __secure_getenv __libc_secure_getenv
#else
# define struct_stat64 struct stat
# define __gen_tempname gen_tempname
# define __mkdir mkdir
# define __open open
-# define __lstat64(file, buf) lstat (file, buf)
+# define __lstat64_time64(file, buf) lstat (file, buf)
# define __stat64(file, buf) stat (file, buf)
# define __getrandom getrandom
# define __clock_gettime64 clock_gettime
direxists (const char *dir)
{
struct_stat64 buf;
- return __stat64 (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
+ return __stat64_time64 (dir, &buf) == 0 && S_ISDIR (buf.st_mode);
}
/* Path search algorithm, for tmpnam, tmpfile, etc. If DIR is
{
struct_stat64 st;
- if (__lstat64 (tmpl, &st) == 0 || errno == EOVERFLOW)
+ if (__lstat64_time64 (tmpl, &st) == 0 || errno == EOVERFLOW)
__set_errno (EEXIST);
return errno == ENOENT ? 0 : -1;
}
DIR *
__fdopendir (int fd)
{
- struct stat64 statbuf;
+ struct __stat64_t64 statbuf;
- if (__builtin_expect (__fstat64 (fd, &statbuf), 0) < 0)
+ if (__glibc_unlikely (__fstat64_time64 (fd, &statbuf) < 0))
return NULL;
if (__glibc_unlikely (! S_ISDIR (statbuf.st_mode)))
{
/* We come here only if the 'execve' call fails. Determine whether
/proc is mounted. If not we return ENOSYS. */
- struct stat64 st;
- if (__stat64 ("/proc/self/fd", &st) != 0 && errno == ENOENT)
+ struct __stat64_t64 st;
+ if (__stat64_time64 ("/proc/self/fd", &st) != 0 && errno == ENOENT)
save = ENOSYS;
__set_errno (save);
/* Now make sure this really is a directory and nothing changed since the
`stat' call. The S_ISDIR check is superfluous if O_DIRECTORY works,
but it's cheap and we need the stat call for st_blksize anyway. */
- struct stat64 statbuf;
- if (__glibc_unlikely (__fstat64 (fd, &statbuf) < 0))
+ struct __stat64_t64 statbuf;
+ if (__glibc_unlikely (__fstat64_time64 (fd, &statbuf) < 0))
goto lose;
if (__glibc_unlikely (! S_ISDIR (statbuf.st_mode)))
{
weak_alias (__opendir, opendir)
DIR *
-__alloc_dir (int fd, bool close_fd, int flags, const struct stat64 *statp)
+__alloc_dir (int fd, bool close_fd, int flags,
+ const struct __stat64_t64 *statp)
{
/* We have to set the close-on-exit flag if the user provided the
file descriptor. */
{
char buf[64];
char path[PATH_MAX];
- struct stat64 st;
+ struct __stat64_t64 st;
- if ((file == NULL ? __fstat64 (fd, &st) : __stat64 (file, &st)) != 0)
+ if ((file == NULL ? __fstat64_time64 (fd, &st)
+ : __stat64_time64 (file, &st)) != 0)
/* Strange. The statfd call worked, but stat fails. Default to
the more pessimistic value. */
return EXT2_LINK_MAX;
linux/Documentation/devices.txt (on linux < 4.10) or
linux/Documentation/admin-guide/devices.txt (on linux >= 4.10). */
static inline bool
-is_pty (struct stat64 *sb)
+is_pty (struct __stat64_t64 *sb)
{
-#ifdef _STATBUF_ST_RDEV
int m = __gnu_dev_major (sb->st_rdev);
return (136 <= m && m <= 143);
-#else
- return false;
-#endif
}
static inline bool
-is_mytty (const struct stat64 *mytty, const struct stat64 *maybe)
+is_mytty (const struct __stat64_t64 *mytty, const struct __stat64_t64 *maybe)
{
return (maybe->st_ino == mytty->st_ino
&& maybe->st_dev == mytty->st_dev
-#ifdef _STATBUF_ST_RDEV
&& S_ISCHR (maybe->st_mode)
&& maybe->st_rdev == mytty->st_rdev
-#endif
);
}
#include "ttyname.h"
static int getttyname_r (char *buf, size_t buflen,
- const struct stat64 *mytty, int save,
+ const struct __stat64_t64 *mytty, int save,
int *dostat);
static int
attribute_compat_text_section
-getttyname_r (char *buf, size_t buflen, const struct stat64 *mytty,
+getttyname_r (char *buf, size_t buflen, const struct __stat64_t64 *mytty,
int save, int *dostat)
{
- struct stat64 st;
+ struct __stat64_t64 st;
DIR *dirstream;
struct dirent64 *d;
size_t devlen = strlen (buf);
cp = __stpncpy (buf + devlen, d->d_name, needed);
cp[0] = '\0';
- if (__stat64 (buf, &st) == 0
+ if (__stat64_time64 (buf, &st) == 0
&& is_mytty (mytty, &st))
{
(void) __closedir (dirstream);
__ttyname_r (int fd, char *buf, size_t buflen)
{
struct fd_to_filename filename;
- struct stat64 st, st1;
+ struct __stat64_t64 st, st1;
int dostat = 0;
int doispty = 0;
int save = errno;
if (__glibc_unlikely (__tcgetattr (fd, &term) < 0))
return errno;
- if (__fstat64 (fd, &st) < 0)
+ if (__fstat64_time64 (fd, &st) < 0)
return errno;
/* We try using the /proc filesystem. */
/* Verify readlink result, fall back on iterating through devices. */
if (buf[0] == '/'
- && __stat64 (buf, &st1) == 0
+ && __stat64_time64 (buf, &st1) == 0
&& is_mytty (&st, &st1))
return 0;
memcpy (buf, "/dev/pts/", sizeof ("/dev/pts/"));
buflen -= sizeof ("/dev/pts/") - 1;
- if (__stat64 (buf, &st1) == 0 && S_ISDIR (st1.st_mode))
+ if (__stat64_time64 (buf, &st1) == 0 && S_ISDIR (st1.st_mode))
{
ret = getttyname_r (buf, buflen, &st, save,
&dostat);
key_t
ftok (const char *pathname, int proj_id)
{
- struct stat64 st;
+ struct __stat64_t64 st;
key_t key;
- if (__stat64 (pathname, &st) < 0)
+ if (__stat64_time64 (pathname, &st) < 0)
return (key_t) -1;
key = ((st.st_ino & 0xffff) | ((st.st_dev & 0xff) << 16)
}
/* If we were already using tzfile, check whether the file changed. */
- struct stat64 st;
+ struct __stat64_t64 st;
if (was_using_tzfile
- && __stat64 (file, &st) == 0
+ && __stat64_time64 (file, &st) == 0
&& tzfile_ino == st.st_ino && tzfile_dev == st.st_dev
&& tzfile_mtime == st.st_mtime)
goto done; /* Nothing to do. */
goto ret_free_transitions;
/* Get information about the file we are actually using. */
- if (__fstat64 (__fileno (f), &st) != 0)
+ if (__fstat64_time64 (__fileno (f), &st) != 0)
goto lose;
free ((void *) transitions);