@@ -36,97 +36,4 @@ weak_alias (__getdents64, getdents64)
#if _DIRENT_MATCHES_DIRENT64
strong_alias (__getdents64, __getdents)
-#else
-# include <shlib-compat.h>
-
-# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
-# include <olddirent.h>
-# include <unistd.h>
-
-static ssize_t
-handle_overflow (int fd, __off64_t offset, ssize_t count)
-{
- /* If this is the first entry in the buffer, we can report the
- error. */
- if (offset == 0)
- {
- __set_errno (EOVERFLOW);
- return -1;
- }
-
- /* Otherwise, seek to the overflowing entry, so that the next call
- will report the error, and return the data read so far. */
- if (__lseek64 (fd, offset, SEEK_SET) != 0)
- return -1;
- return count;
-}
-
-ssize_t
-__old_getdents64 (int fd, char *buf, size_t nbytes)
-{
- /* We do not move the individual directory entries. This is only
- possible if the target type (struct __old_dirent64) is smaller
- than the source type. */
- _Static_assert (offsetof (struct __old_dirent64, d_name)
- <= offsetof (struct dirent64, d_name),
- "__old_dirent64 is larger than dirent64");
- _Static_assert (__alignof__ (struct __old_dirent64)
- <= __alignof__ (struct dirent64),
- "alignment of __old_dirent64 is larger than dirent64");
-
- ssize_t retval = INLINE_SYSCALL_CALL (getdents64, fd, buf, nbytes);
- if (retval > 0)
- {
- /* This is the marker for the first entry. Offset 0 is reserved
- for the first entry (see rewinddir). Here, we use it as a
- marker for the first entry in the buffer. We never actually
- seek to offset 0 because handle_overflow reports the error
- directly, so it does not matter that the offset is incorrect
- if entries have been read from the descriptor before (so that
- the descriptor is not actually at offset 0). */
- __off64_t previous_offset = 0;
-
- char *p = buf;
- char *end = buf + retval;
- while (p < end)
- {
- struct dirent64 *source = (struct dirent64 *) p;
-
- /* Copy out the fixed-size data. */
- __ino_t ino = source->d_ino;
- __off64_t offset = source->d_off;
- unsigned int reclen = source->d_reclen;
- unsigned char type = source->d_type;
-
- /* Check for ino_t overflow. */
- if (__glibc_unlikely (ino != source->d_ino))
- return handle_overflow (fd, previous_offset, p - buf);
-
- /* Convert to the target layout. Use a separate struct and
- memcpy to side-step aliasing issues. */
- struct __old_dirent64 result;
- result.d_ino = ino;
- result.d_off = offset;
- result.d_reclen = reclen;
- result.d_type = type;
-
- /* Write the fixed-sized part of the result to the
- buffer. */
- size_t result_name_offset = offsetof (struct __old_dirent64, d_name);
- memcpy (p, &result, result_name_offset);
-
- /* Adjust the position of the name if necessary. Copy
- everything until the end of the record, including the
- terminating NUL byte. */
- if (result_name_offset != offsetof (struct dirent64, d_name))
- memmove (p + result_name_offset, source->d_name,
- reclen - offsetof (struct dirent64, d_name));
-
- p += reclen;
- previous_offset = offset;
- }
- }
- return retval;
-}
-# endif /* SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) */
-#endif /* _DIRENT_MATCHES_DIRENT64 */
+#endif
@@ -36,8 +36,6 @@ extern struct __old_dirent64 *__old_readdir64_unlocked (DIR *__dirp)
attribute_hidden;
extern int __old_readdir64_r (DIR *__dirp, struct __old_dirent64 *__entry,
struct __old_dirent64 **__result);
-extern __ssize_t __old_getdents64 (int __fd, char *__buf, size_t __nbytes)
- attribute_hidden;
int __old_scandir64 (const char * __dir,
struct __old_dirent64 *** __namelist,
int (*__selector) (const struct __old_dirent64 *),
@@ -21,6 +21,7 @@
#if !_DIRENT_MATCHES_DIRENT64
# include <dirstream.h>
+# include <olddirent.h>
/* getdents64 is used internally for both LFS and non-LFS implementations.
The non-LFS interface reserves part of the allocated buffer to return the
@@ -106,9 +107,53 @@ dirstream_ret_entry (struct __dirstream *ds)
return dp;
}
+
+/* Return the allocated buffer used on LFS compat readdir call. */
+static inline struct __old_dirent64 *
+dirstream_ret64_compat (struct __dirstream *ds)
+{
+ return (struct __old_dirent64 *) ds->data;
+}
+
+static inline struct __old_dirent64 *
+dirstream_ret_entry64_compat (struct __dirstream *ds)
+{
+ struct dirent64 *dp64 = dirstream_entry (ds);
+ struct __old_dirent64 *dp64_compat = dirstream_ret64_compat (ds);
+
+ dp64_compat->d_ino = dp64->d_ino;
+ if (dp64_compat->d_ino != dp64->d_ino)
+ /* Overflow. */
+ return NULL;
+
+ dp64_compat->d_off = dp64->d_off;
+
+ const size_t size_diff = (offsetof (struct dirent64, d_name)
+ - offsetof (struct __old_dirent64, d_name));
+ const size_t alignment = _Alignof (struct __old_dirent64);
+ size_t new_reclen = (dp64->d_reclen - size_diff + alignment - 1)
+ & ~(alignment - 1);
+ if (new_reclen > return_buffer_size)
+ /* Overflow. */
+ return NULL;
+
+ /* The compat symbol report the kernel obtained d_reclen, even though
+ it has an incompatible dirent layout. */
+ dp64_compat->d_reclen = dp64->d_reclen;
+
+ dp64_compat->d_type = dp64->d_type;
+
+ memcpy (dp64_compat->d_name, dp64->d_name,
+ dp64->d_reclen - offsetof (struct dirent64, d_name));
+
+ ds->offset += dp64->d_reclen;
+ ds->filepos = dp64->d_off;
+
+ return dp64_compat;
+}
+
#else
/* No need to reserve an buffer space if dirent has already LFS support. */
enum { return_buffer_size = 0 };
#endif /* _DIRENT_MATCHES_DIRENT64 */
-
#endif
@@ -112,27 +112,23 @@ weak_alias (__readdir64, readdir64)
versioned_symbol (libc, __readdir64, readdir64, GLIBC_2_2);
# endif
# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2)
-# include <olddirent.h>
+# include <readdir.h>
+# include <unistd.h>
attribute_compat_text_section
struct __old_dirent64 *
__old_readdir64_unlocked (DIR *dirp)
{
struct __old_dirent64 *dp;
- int saved_errno = errno;
+ const int saved_errno = errno;
do
{
- size_t reclen;
-
if (dirp->offset >= dirp->size)
{
/* We've emptied out our buffer. Refill it. */
-
- size_t maxread = dirp->allocation;
- ssize_t bytes;
-
- bytes = __old_getdents64 (dirp->fd, dirp->data, maxread);
+ ssize_t bytes = __getdents64 (dirp->fd, dirstream_data (dirp),
+ dirstream_alloc_size (dirp));
if (bytes <= 0)
{
/* On some systems getdents fails with ENOENT when the
@@ -153,13 +149,12 @@ __old_readdir64_unlocked (DIR *dirp)
dirp->offset = 0;
}
- dp = (struct __old_dirent64 *) &dirp->data[dirp->offset];
-
- reclen = dp->d_reclen;
-
- dirp->offset += reclen;
-
- dirp->filepos = dp->d_off;
+ dp = dirstream_ret_entry64_compat (dirp);
+ if (dp == NULL)
+ {
+ __set_errno (EOVERFLOW);
+ break;
+ }
/* Skip deleted files. */
} while (dp->d_ino == 0);