From patchwork Thu Jan 26 19:29:53 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 63759 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 79112383FB99 for ; Thu, 26 Jan 2023 19:31:48 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 79112383FB99 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1674761508; bh=qF7bEgJn2WPvm1dO+pvIBsWrhCqraglUUcB/sjjnE5Q=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=JmJ59PeWQoJpSvJ+18Wfy8w+vIlN+/MrJS1eN8HzVN0jr2opLq6AbmdZZ1iLzUcfI CTmDI/oPOd+F5tN7qX9Pqd3gKPW+bf5Y9Q+KsJmpS7/5Bt6fr6jG2RA8TlGDsXH1FN BrgsmfNPn4zLyRQLA6jzoSCPbplMuR1bTYQ+PATk= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-oi1-x230.google.com (mail-oi1-x230.google.com [IPv6:2607:f8b0:4864:20::230]) by sourceware.org (Postfix) with ESMTPS id 818273857C51 for ; Thu, 26 Jan 2023 19:30:08 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 818273857C51 Received: by mail-oi1-x230.google.com with SMTP id i5so2293341oih.11 for ; Thu, 26 Jan 2023 11:30:08 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=qF7bEgJn2WPvm1dO+pvIBsWrhCqraglUUcB/sjjnE5Q=; b=s2eimaoX9PPBm1saRaoWcxLsMj+q2XoNJIz2LTw2KLo6sJaXVMFZitJ5MarwvAEVxr uKTY+6MW7nMn2pF6JC4wd6Piplw5sGlnMKGYv9MA8s0Qkc5S26S2qhX9qWSLk5ElRW4X 3RVaN5YWvEnrqiqWhodH1Puh7uBEZAieRLZdRp9foi1hvoe5q3+aHV8l/DjdVZvVrTHD o7LHzRNvhiWqIMAV7Piai+Io7NqAxiNPjwdA4S5bt4D8yahzRPNnCvY9vhAUoPLgUwZT j1dQura80lpvAcb+9RAIdENENTMSBjM7ajTu03EY8fYUjqohi8NviRbCTYqXbhDHTnd3 RXLA== X-Gm-Message-State: AO0yUKXlnl3IzoBKimmFfU9PXUnvlACZUfjJg+8kgKKdn+pd8ZKUgD7X j1MSwYxzPg1fRSNrpp62NF0zlL38TjNfOYzOjaI= X-Google-Smtp-Source: AK7set+4tJgzKlP56wHJyleMYZ/0LE22cCY0fnVBN4Ps/6aDk2zH1rbK8TIVLEId/QHXmMHYG5gOLA== X-Received: by 2002:a54:440b:0:b0:364:7618:8d1e with SMTP id k11-20020a54440b000000b0036476188d1emr1461377oiw.34.1674761407057; Thu, 26 Jan 2023 11:30:07 -0800 (PST) Received: from mandiga.. ([2804:1b3:a7c1:7e99:732:4c6b:2122:8111]) by smtp.gmail.com with ESMTPSA id v23-20020a056830091700b00670641eb272sm872939ott.20.2023.01.26.11.30.05 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 26 Jan 2023 11:30:06 -0800 (PST) To: libc-alpha@sourceware.org, "Andreas K . Huettel" Subject: [PATCH v4 5/5] linux: Use getdents64 on readdir64 compat implementation Date: Thu, 26 Jan 2023 16:29:53 -0300 Message-Id: <20230126192953.2990973-6-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20230126192953.2990973-1-adhemerval.zanella@linaro.org> References: <20230126192953.2990973-1-adhemerval.zanella@linaro.org> MIME-Version: 1.0 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Adhemerval Zanella via Libc-alpha From: Adhemerval Zanella Netto Reply-To: Adhemerval Zanella Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" It uses a similar strategy from the non-LFS readdir that also uses getdents64 internally and uses a translation buffer to return the compat readdir64 entry. It allows to remove __old_getdents64. Checked on i686-linux-gnu. --- sysdeps/unix/sysv/linux/getdents64.c | 93 ---------------------------- sysdeps/unix/sysv/linux/olddirent.h | 2 - sysdeps/unix/sysv/linux/opendir.c | 15 ++++- sysdeps/unix/sysv/linux/readdir64.c | 62 +++++++++++++++---- 4 files changed, 64 insertions(+), 108 deletions(-) diff --git a/sysdeps/unix/sysv/linux/getdents64.c b/sysdeps/unix/sysv/linux/getdents64.c index 01c3517deb..db299864ed 100644 --- a/sysdeps/unix/sysv/linux/getdents64.c +++ b/sysdeps/unix/sysv/linux/getdents64.c @@ -36,97 +36,4 @@ weak_alias (__getdents64, getdents64) #if _DIRENT_MATCHES_DIRENT64 strong_alias (__getdents64, __getdents) -#else -# include - -# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) -# include -# include - -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 */ diff --git a/sysdeps/unix/sysv/linux/olddirent.h b/sysdeps/unix/sysv/linux/olddirent.h index cde95e192e..2d682a6919 100644 --- a/sysdeps/unix/sysv/linux/olddirent.h +++ b/sysdeps/unix/sysv/linux/olddirent.h @@ -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 *), diff --git a/sysdeps/unix/sysv/linux/opendir.c b/sysdeps/unix/sysv/linux/opendir.c index 01c05f0c6c..5bd45928e7 100644 --- a/sysdeps/unix/sysv/linux/opendir.c +++ b/sysdeps/unix/sysv/linux/opendir.c @@ -23,6 +23,11 @@ #include +#include +#if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) +# include +#endif + enum { opendir_oflags = O_RDONLY|O_NDELAY|O_DIRECTORY|O_LARGEFILE|O_CLOEXEC }; @@ -128,7 +133,15 @@ __alloc_dir (int fd, bool close_fd, int flags, it if required (i.e for names larger than NAME_MAX). */ enum { - tbuffer_size = sizeof (struct dirent) + NAME_MAX + 1 + tbuffer_size = +# if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) + /* This is used on compat readdir64. */ + MAX (sizeof (struct dirent), + sizeof (struct __old_dirent64)) +# else + sizeof (struct dirent) +# endif + + NAME_MAX + 1 }; dirp->tbuffer = malloc (tbuffer_size); if (dirp->tbuffer == NULL) diff --git a/sysdeps/unix/sysv/linux/readdir64.c b/sysdeps/unix/sysv/linux/readdir64.c index b901071aa7..7651eeb08e 100644 --- a/sysdeps/unix/sysv/linux/readdir64.c +++ b/sysdeps/unix/sysv/linux/readdir64.c @@ -102,21 +102,52 @@ versioned_symbol (libc, __readdir64, readdir64, GLIBC_2_2); # if SHLIB_COMPAT(libc, GLIBC_2_1, GLIBC_2_2) # include +/* Translate the DP64 entry to the old 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_old_entry (struct __dirstream *ds, const struct dirent64 *dp64) +{ + /* Check for overflow. */ + ino_t d_ino = dp64->d_ino; + if (d_ino != dp64->d_ino) + return false; + + /* Expand the translation buffer to hold the new namesize. */ + size_t d_reclen = sizeof (struct __old_dirent64) + + dp64->d_reclen - offsetof (struct dirent64, d_name); + if (d_reclen > ds->tbuffer_size) + { + char *newbuffer = realloc (ds->tbuffer, d_reclen); + if (newbuffer == NULL) + return false; + ds->tbuffer = newbuffer; + ds->tbuffer_size = d_reclen; + } + + struct __old_dirent64 *olddp64 = (struct __old_dirent64 *) ds->tbuffer; + + olddp64->d_off = dp64->d_off; + olddp64->d_ino = dp64->d_ino; + olddp64->d_reclen = dp64->d_reclen; + olddp64->d_type = dp64->d_type; + memcpy (olddp64->d_name, dp64->d_name, + dp64->d_reclen - offsetof (struct dirent64, d_name)); + + return true; +} + 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; 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, dirp->data, dirp->allocation); if (bytes <= 0) { /* Linux may fail with ENOENT on some file systems if the @@ -127,17 +158,24 @@ __old_readdir64_unlocked (DIR *dirp) __set_errno (saved_errno); return NULL; } - dirp->size = (size_t) bytes; + dirp->size = bytes; /* Reset the offset into the buffer. */ dirp->offset = 0; } - dp = (struct __old_dirent64 *) &dirp->data[dirp->offset]; - dirp->offset += dp->d_reclen; - dirp->filepos = dp->d_off; + struct dirent64 *dp64 = (struct dirent64 *) &dirp->data[dirp->offset]; + dirp->offset += dp64->d_reclen; - return dp; + /* Skip entries which might overflow d_ino or for memory allocation failure + in case of large file names. */ + if (dirstream_old_entry (dirp, dp64)) + { + dirp->filepos = dp64->d_off; + return (struct __old_dirent64 *) dirp->tbuffer; + } + + return NULL; } attribute_compat_text_section