From patchwork Wed Jul 31 18:31:32 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella X-Patchwork-Id: 170204 Delivered-To: patch@linaro.org Received: by 2002:ac9:2daa:0:0:0:0:0 with SMTP id g42csp6294712oce; Wed, 31 Jul 2019 11:31:54 -0700 (PDT) X-Google-Smtp-Source: APXvYqx0Hbb+KtLHMBGJ7Ewi6KdwMDFkyK4Pq0VdgQHAnErglZZsDmbf1oV82UAc2pgDekhDL8FU X-Received: by 2002:a17:90a:9386:: with SMTP id q6mr4209325pjo.81.1564597914868; Wed, 31 Jul 2019 11:31:54 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1564597914; cv=none; d=google.com; s=arc-20160816; b=g2kP89f6Xsp640tCg8tL8nPyQ86vyDHkh8IWMjs+dWA1dSLVfAcbLfD1HOCDuMZhVE e3ovLv5JT92w2g1iGvP01cAG/ZzgdXS0NXkbWWXa7qXora0n3jvc64UiAUnjrcIpegHT R5drI1A+lqqz1AfWn7S/EMDXTDnyPO5lO2kz4JRgxv7PmksyLHCc61LojSoiAPIyAoI0 Xa7Ggi1zFy8twcZCubzdNCIYg9UTa4rL1gYGodJj0VxCHdQ45Kt+V76IUIqw6XZAW1Jd ZNYrP/njHWZU5VAdxlqbt/LoJIUwv9YYMLCFoKE9+LuqDZD9vmH3cJVIYV2uBoadPW+G fgnQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=message-id:date:subject:to:from:dkim-signature:delivered-to:sender :list-help:list-post:list-archive:list-subscribe:list-unsubscribe :list-id:precedence:mailing-list:dkim-signature:domainkey-signature; bh=uujKKiaFQSuV6+tEBdmXKlpITJ6uszb/OBs3WzZXiEU=; b=YRpOieSrrE2sE/AKUpbKI6sMmOj6D0SRS21VZOe5R5qjHYttqsz8Kjj/c6HcKSitjH q8h6t4qe0d7PKKRdj8ylLS59CfYvUtMklBZDYfQ7PHz1MaYk8mdWKRjZz/89ZimmCo11 zv7kl7MWc/1TvXsojsGSLMgXioPEP47PlLufHJbMemLlbX7QDH4XSPfw6TVehfIzKR29 bzsAc6i7UGqFxIRPuhSwwipj2W/ePiZCiWoJA13UMapE4luidVOcgLTD0h8EhO0GSwvn hYgvkoybDEveGdjybK96+0p3GZaHLfDItcS8GVa8Hj8w13yDu7aW486MXU9zNFWMha1F e0Eg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=UzAJJLye; dkim=pass header.i=@linaro.org header.s=google header.b=r7B77di0; spf=pass (google.com: domain of libc-alpha-return-104073-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom="libc-alpha-return-104073-patch=linaro.org@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id k72si36050667pge.95.2019.07.31.11.31.54 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 31 Jul 2019 11:31:54 -0700 (PDT) Received-SPF: pass (google.com: domain of libc-alpha-return-104073-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@sourceware.org header.s=default header.b=UzAJJLye; dkim=pass header.i=@linaro.org header.s=google header.b=r7B77di0; spf=pass (google.com: domain of libc-alpha-return-104073-patch=linaro.org@sourceware.org designates 209.132.180.131 as permitted sender) smtp.mailfrom="libc-alpha-return-104073-patch=linaro.org@sourceware.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id; q=dns; s= default; b=oLKne2bkilr4uvqEpGaB7Kw5CNtFYpiJVXHL5OEX7fImV6hN4hI66 9PcIwalEKz3JKahWVjyTgU9E4ZKsf8vd/9nBRl+vCLEsx+IIoP0zH3q9ueCiCZ8a 4syaalTH8dYNARKzv5Y3CxQc48YUAgLBvLbF2hNoqopmQx/hkA1pY0= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:subject:date:message-id; s=default; bh=UOFESxQPEbJRJzak1ffKHuePnVo=; b=UzAJJLyePrWbFrIW6jn4fXVFuEiS zMn0p27gkm1X4eypbMMCILxcm73IkCmPGwyW3Yju2RXkX+4fkDCJsBMcJY8ek3KL zxui5Sp1Og2fjsEaIapzBKCFCC+GQgjsvdeP00ikXSJxiGbbqpWaML5vc7NpeIl5 wosEcIPuifOXHq8= Received: (qmail 122212 invoked by alias); 31 Jul 2019 18:31:45 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 122204 invoked by uid 89); 31 Jul 2019 18:31:44 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-15.8 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy=offsetof, Our X-HELO: mail-qt1-f196.google.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:subject:date:message-id; bh=uujKKiaFQSuV6+tEBdmXKlpITJ6uszb/OBs3WzZXiEU=; b=r7B77di0zkdgNvPkidszJW5/Hcm7ICMCZ40/00t/TVIgdqw+/txdjLrE2sOr6Kk4bX aMNCwYX4ylgCDMvJIu2yBXX8FsxhVObBq50tqdLPTEKZb8F9aOWbF+GmNPbzqgwasnc2 Ti1b7pjgM3rG4XYBA+BIJ1Thnu75p+2INdv5LON1btoHnd8T0BDC9pPLPzFRlck03iM5 2A+aNlHmdvTaKfqNINb1igwEfTjAD4N/FadkUk0PiFw1ea7BySCIlXjcphQ4Yb/NSOuE Ws/r4VRrRu8Q2Umpb6sgnBg4RfSEIJz7LpHKMEiuiDl+nNib/Fl72uhVpJk/OTjG9v1I B+cg== Return-Path: From: Adhemerval Zanella To: libc-alpha@sourceware.org Subject: [PATCH v2 1/5] mips: Do not malloc on getdents64 fallback Date: Wed, 31 Jul 2019 15:31:32 -0300 Message-Id: <20190731183136.21545-1-adhemerval.zanella@linaro.org> This patch changes how the fallback getdents64 implementation calls non-LFS getdents by replacing the scratch_buffer with static buffer plus a loop on getdents calls. This avoids the potential malloc call on scratch_buffer_set_array_size for large input buffer size at the cost of more getdents syscalls. It also adds a small optimization for older kernels, where the first ENOSYS failure for getdents64 disable subsequent calls. Check the dirent tests on a mips64-linux-gnu with getdents64 code disabled. * sysdeps/unix/sysv/linux/mips/mips64/getdents64.c (__getdents64): Add small optimization for older kernel to avoid issuing __NR_getdents64 on each call and replace scratch_buffer usage with a static allocated buffer. --- .../unix/sysv/linux/mips/mips64/getdents64.c | 122 ++++++++---------- 1 file changed, 54 insertions(+), 68 deletions(-) -- 2.17.1 diff --git a/sysdeps/unix/sysv/linux/mips/mips64/getdents64.c b/sysdeps/unix/sysv/linux/mips/mips64/getdents64.c index 8bf3abb0e0..3b5afd9324 100644 --- a/sysdeps/unix/sysv/linux/mips/mips64/getdents64.c +++ b/sysdeps/unix/sysv/linux/mips/mips64/getdents64.c @@ -22,98 +22,84 @@ #include #include #include -#include #include ssize_t -__getdents64 (int fd, void *buf0, size_t nbytes) +__getdents64 (int fd, void *buf, size_t nbytes) { - char *buf = buf0; - /* The system call takes an unsigned int argument, and some length checks in the kernel use an int type. */ if (nbytes > INT_MAX) nbytes = INT_MAX; #ifdef __NR_getdents64 - ssize_t ret = INLINE_SYSCALL_CALL (getdents64, fd, buf, nbytes); - if (ret != -1) - return ret; + static bool getdents64_supportted = true; + if (atomic_load_relaxed (&getdents64_supportted)) + { + ssize_t ret = INLINE_SYSCALL_CALL (getdents64, fd, buf, nbytes); + if (ret >= 0 || errno != ENOSYS) + return ret; + + atomic_store_relaxed (&getdents64_supportted, false); + } #endif /* Unfortunately getdents64 was only wire-up for MIPS n64 on Linux 3.10. - If syscall is not available it need to fallback to non-LFS one. */ + If the syscall is not available it need to fallback to the non-LFS one. + Also to avoid an unbounded allocation through VLA/alloca or malloc (which + would make the syscall non async-signal-safe) it uses a limited buffer. + This is sub-optimal for large NBYTES, however this is a fallback + mechanism to emulate a syscall that kernel should provide. */ + enum { KBUF_SIZE = 1024 }; struct kernel_dirent - { - unsigned long d_ino; - unsigned long d_off; - unsigned short int d_reclen; - char d_name[256]; - }; - - const size_t size_diff = (offsetof (struct dirent64, d_name) - - offsetof (struct kernel_dirent, d_name)); - - size_t red_nbytes = MIN (nbytes - - ((nbytes / (offsetof (struct dirent64, d_name) - + 14)) * size_diff), - nbytes - size_diff); - - struct scratch_buffer tmpbuf; - scratch_buffer_init (&tmpbuf); - if (!scratch_buffer_set_array_size (&tmpbuf, red_nbytes, sizeof (uint8_t))) - INLINE_SYSCALL_ERROR_RETURN_VALUE (ENOMEM); - - struct kernel_dirent *skdp, *kdp; - skdp = kdp = tmpbuf.data; - - ssize_t retval = INLINE_SYSCALL_CALL (getdents, fd, kdp, red_nbytes); - if (retval == -1) - { - scratch_buffer_free (&tmpbuf); - return -1; - } + { + unsigned long d_ino; + unsigned long d_off; + unsigned short int d_reclen; + char d_name[1]; + } kbuf[KBUF_SIZE / sizeof (struct kernel_dirent)]; + size_t kbuf_size = nbytes < KBUF_SIZE ? nbytes : KBUF_SIZE; - off64_t last_offset = -1; struct dirent64 *dp = (struct dirent64 *) buf; - while ((char *) kdp < (char *) skdp + retval) + + size_t nb = 0; + off64_t last_offset = -1; + + ssize_t r; + while ((r = INLINE_SYSCALL_CALL (getdents, fd, kbuf, kbuf_size)) > 0) { - const size_t alignment = _Alignof (struct dirent64); - /* Since kdp->d_reclen is already aligned for the kernel structure - this may compute a value that is bigger than necessary. */ - size_t new_reclen = ((kdp->d_reclen + size_diff + alignment - 1) - & ~(alignment - 1)); - if ((char *) dp + new_reclen > buf + nbytes) - { - /* Our heuristic failed. We read too many entries. Reset - the stream. */ - assert (last_offset != -1); - __lseek64 (fd, last_offset, SEEK_SET); - - if ((char *) dp == buf) + struct kernel_dirent *skdp, *kdp; + skdp = kdp = kbuf; + + while ((char *) kdp < (char *) skdp + r) + { + const size_t alignment = _Alignof (struct dirent64); + size_t new_reclen = ((kdp->d_reclen + alignment - 1) + & ~(alignment - 1)); + if (nb + new_reclen > nbytes) { - scratch_buffer_free (&tmpbuf); - return INLINE_SYSCALL_ERROR_RETURN_VALUE (EINVAL); + /* The new entry will overflow the input buffer, rewind to + last obtained entry and return. */ + __lseek64 (fd, last_offset, SEEK_SET); + goto out; } + nb += new_reclen; - break; - } - - last_offset = kdp->d_off; - dp->d_ino = kdp->d_ino; - dp->d_off = kdp->d_off; - dp->d_reclen = new_reclen; - dp->d_type = *((char *) kdp + kdp->d_reclen - 1); - memcpy (dp->d_name, kdp->d_name, - kdp->d_reclen - offsetof (struct kernel_dirent, d_name)); + dp->d_ino = kdp->d_ino; + dp->d_off = last_offset = kdp->d_off; + dp->d_reclen = new_reclen; + dp->d_type = *((char *) kdp + kdp->d_reclen - 1); + memcpy (dp->d_name, kdp->d_name, + kdp->d_reclen - offsetof (struct kernel_dirent, d_name)); - dp = (struct dirent64 *) ((char *) dp + new_reclen); - kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen); + dp = (struct dirent64 *) ((char *) dp + new_reclen); + kdp = (struct kernel_dirent *) (((char *) kdp) + kdp->d_reclen); + } } - scratch_buffer_free (&tmpbuf); - return (char *) dp - buf; +out: + return (char *) dp - (char *) buf; } libc_hidden_def (__getdents64) weak_alias (__getdents64, getdents64)