From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1791) id 01CE93858408; Thu, 26 Jan 2023 12:17:28 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 01CE93858408 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1674735448; bh=84WV23KFbSCw4YvcGYg+O3Vck1Y5ttwrFQtzv0WSPfo=; h=From:To:Subject:Date:From; b=nu42uypnZ18fgWE1iRM8TSnGy4oPNzH9KyEDshaa/hFS/Ia3R5TBboyoSgeSrSLCS WiFpUZrWbZUXVpL4Jn9f1/qPwwwEsaHYEm+KeXGhmh6dhkglVO1ay+iwX77ZrbmY3x 8pcSdK+uxKKiCQWb3ReMGS3GjLTA3OvUmJirwcjc= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Adhemerval Zanella To: glibc-cvs@sourceware.org Subject: [glibc/azanella/bz23960-dirent] linux: Use getdents64 on non-LFS readdir X-Act-Checkin: glibc X-Git-Author: Adhemerval Zanella X-Git-Refname: refs/heads/azanella/bz23960-dirent X-Git-Oldrev: 0d50f477f47ba637b54fb03ac48d769ec4543e8d X-Git-Newrev: 60341f8c192a61a5830eb30d52f1c995a01a3f6d Message-Id: <20230126121728.01CE93858408@sourceware.org> Date: Thu, 26 Jan 2023 12:17:28 +0000 (GMT) List-Id: https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=60341f8c192a61a5830eb30d52f1c995a01a3f6d commit 60341f8c192a61a5830eb30d52f1c995a01a3f6d Author: Adhemerval Zanella Date: Tue Oct 20 13:37:15 2020 -0300 linux: Use getdents64 on non-LFS readdir The opendir allocates a translation buffer to be used to return the non-LFS readdir entry. The obtained dirent64 struct is translated to the temporary buffer on each readdir call. Entries that overflow d_off/d_ino and the buffer reallocation failure (in case of large d_name) are ignored. Checked on x86_64-linux-gnu and i686-linux-gnu. Diff: --- sysdeps/unix/sysv/linux/closedir.c | 4 ++ sysdeps/unix/sysv/linux/dirstream.h | 5 ++ sysdeps/unix/sysv/linux/opendir.c | 21 +++++++++ sysdeps/unix/sysv/linux/readdir.c | 94 +++++++++++++++++++++++++++---------- 4 files changed, 98 insertions(+), 26 deletions(-) diff --git a/sysdeps/unix/sysv/linux/closedir.c b/sysdeps/unix/sysv/linux/closedir.c index f1c2608642..8adbc99892 100644 --- a/sysdeps/unix/sysv/linux/closedir.c +++ b/sysdeps/unix/sysv/linux/closedir.c @@ -47,6 +47,10 @@ __closedir (DIR *dirp) __libc_lock_fini (dirp->lock); #endif +#if !_DIRENT_MATCHES_DIRENT64 + free (dirp->tbuffer); +#endif + free ((void *) dirp); return __close_nocancel (fd); diff --git a/sysdeps/unix/sysv/linux/dirstream.h b/sysdeps/unix/sysv/linux/dirstream.h index 3cb313b410..cd8bc56276 100644 --- a/sysdeps/unix/sysv/linux/dirstream.h +++ b/sysdeps/unix/sysv/linux/dirstream.h @@ -41,6 +41,11 @@ struct __dirstream int errcode; /* Delayed error code. */ +#if !defined __OFF_T_MATCHES_OFF64_T || !defined __INO_T_MATCHES_INO64_T + char *tbuffer; /* Translation buffer for non-LFS calls. */ + size_t tbuffer_size; /* Size of translation buffer. */ +#endif + /* Directory block. We must make sure that this block starts at an address that is aligned adequately enough to store dirent entries. Using the alignment of "void *" is not diff --git a/sysdeps/unix/sysv/linux/opendir.c b/sysdeps/unix/sysv/linux/opendir.c index 4336196a4d..52818829dc 100644 --- a/sysdeps/unix/sysv/linux/opendir.c +++ b/sysdeps/unix/sysv/linux/opendir.c @@ -120,6 +120,27 @@ __alloc_dir (int fd, bool close_fd, int flags, return NULL; } +#if !_DIRENT_MATCHES_DIRENT64 + /* Allocates a translation buffer to use as the returned 'struct direct' + for non-LFS 'readdir' calls. + + The initial NAME_MAX size should handle most cases, while readdir might + expand the buffer if required. */ + enum + { + tbuffer_size = sizeof (struct dirent) + NAME_MAX + 1 + }; + dirp->tbuffer = malloc (tbuffer_size); + if (dirp->tbuffer == NULL) + { + free (dirp); + if (close_fd) + __close_nocancel_nostatus (fd); + return NULL; + } + dirp->tbuffer_size = tbuffer_size; +#endif + dirp->fd = fd; #if IS_IN (libc) __libc_lock_init (dirp->lock); diff --git a/sysdeps/unix/sysv/linux/readdir.c b/sysdeps/unix/sysv/linux/readdir.c index 4a4c00ea07..cee88d1ed2 100644 --- a/sysdeps/unix/sysv/linux/readdir.c +++ b/sysdeps/unix/sysv/linux/readdir.c @@ -21,42 +21,84 @@ #if !_DIRENT_MATCHES_DIRENT64 #include +/* Translate the DP64 entry to the non-LFS one in the translation buffer + at dirstream DS. Return true is the translation was possible or + false if either an internal fields can be represented in the non-LFS + entry or if the translation can not be resized. */ +static bool +dirstream_entry (struct __dirstream *ds, const struct dirent64 *dp64) +{ + off_t d_off = dp64->d_off; + if (d_off != dp64->d_off) + return false; + ino_t d_ino = dp64->d_ino; + if (d_ino != dp64->d_ino) + return false; + + /* Expand the translation buffer to hold the new name size. */ + size_t new_reclen = sizeof (struct dirent) + + dp64->d_reclen - offsetof (struct dirent64, d_name); + if (new_reclen > ds->tbuffer_size) + { + char *newbuffer = realloc (ds->tbuffer, new_reclen); + if (newbuffer == NULL) + return false; + ds->tbuffer = newbuffer; + ds->tbuffer_size = new_reclen; + } + + struct dirent *dp = (struct dirent *) ds->tbuffer; + + dp->d_off = d_off; + dp->d_ino = d_ino; + dp->d_reclen = new_reclen; + dp->d_type = dp64->d_type; + memcpy (dp->d_name, dp64->d_name, + dp64->d_reclen - offsetof (struct dirent64, d_name)); + + return true; +} + /* Read a directory entry from DIRP. */ struct dirent * __readdir_unlocked (DIR *dirp) { - struct dirent *dp; int saved_errno = errno; - if (dirp->offset >= dirp->size) + while (1) { - /* We've emptied out our buffer. Refill it. */ - - size_t maxread = dirp->allocation; - ssize_t bytes; - - bytes = __getdents (dirp->fd, dirp->data, maxread); - if (bytes <= 0) + if (dirp->offset >= dirp->size) + { + /* We've emptied out our buffer. Refill it. */ + ssize_t bytes = __getdents64 (dirp->fd, dirp->data, + dirp->allocation); + if (bytes <= 0) + { + /* Linux may fail with ENOENT on some file systems if the + directory inode is marked as dead (deleted). POSIX + treats this as a regular end-of-directory condition, so + do not set errno in that case, to indicate success. */ + if (bytes < 0 && errno == ENOENT) + __set_errno (saved_errno); + return NULL; + } + dirp->size = bytes; + + /* Reset the offset into the buffer. */ + dirp->offset = 0; + } + + struct dirent64 *dp64 = (struct dirent64 *) &dirp->data[dirp->offset]; + dirp->offset += dp64->d_reclen; + + /* Skip entries which might overflow d_off/d_ino or if the translation + buffer can't be resized. */ + if (dirstream_entry (dirp, dp64)) { - /* Linux may fail with ENOENT on some file systems if the - directory inode is marked as dead (deleted). POSIX - treats this as a regular end-of-directory condition, so - do not set errno in that case, to indicate success. */ - if (bytes == 0 || errno == ENOENT) - __set_errno (saved_errno); - return NULL; + dirp->filepos = dp64->d_off; + return (struct dirent *) dirp->tbuffer; } - dirp->size = (size_t) bytes; - - /* Reset the offset into the buffer. */ - dirp->offset = 0; } - - dp = (struct dirent *) &dirp->data[dirp->offset]; - dirp->offset += dp->d_reclen; - dirp->filepos = dp->d_off; - - return dp; } struct dirent *