From patchwork Fri Aug 21 22:39:38 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Lu, Hongjiu" X-Patchwork-Id: 8384 Received: (qmail 124166 invoked by alias); 21 Aug 2015 22:39:42 -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 124153 invoked by uid 89); 21 Aug 2015 22:39:41 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-0.6 required=5.0 tests=AWL, BAYES_50, KAM_LAZY_DOMAIN_SECURITY, NO_DNS_FOR_FROM, RP_MATCHES_RCVD autolearn=no version=3.3.2 X-HELO: mga03.intel.com X-ExtLoop1: 1 Date: Fri, 21 Aug 2015 15:39:38 -0700 From: "H.J. Lu" To: GNU C Library Subject: RFC: [PATCH] Avoid reading errno in syscall implementations Message-ID: <20150821223938.GB3889@intel.com> Reply-To: "H.J. Lu" MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.23 (2014-03-12) Reading errno is expensive for x86 PIC. With INTERNAL_SYSCALL, INTERNAL_SYSCALL_ERROR_P, INTERNAL_SYSCALL_ERRNO and INLINE_SYSCALL_ERROR_RETURN, we can avoid reading errno. * sysdeps/unix/sysv/linux/eventfd.c (eventfd): Use INTERNAL_SYSCALL, INTERNAL_SYSCALL_ERROR_P and INTERNAL_SYSCALL_ERRNO to avoid reading errno. * sysdeps/unix/sysv/linux/fstatfs64.c (__fstatfs64): Likewise. * sysdeps/unix/sysv/linux/getrlimit64.c (__getrlimit64): Likewise. * sysdeps/unix/sysv/linux/setrlimit64.c (setrlimit64): Likewise. * sysdeps/unix/sysv/linux/signalfd.c (signalfd): Likewise. * sysdeps/unix/sysv/linux/statfs64.c (__statfs64): Likewise. --- sysdeps/unix/sysv/linux/eventfd.c | 10 +++++++--- sysdeps/unix/sysv/linux/fstatfs64.c | 12 ++++++++---- sysdeps/unix/sysv/linux/getrlimit64.c | 7 +++++-- sysdeps/unix/sysv/linux/lxstat64.c | 6 ++++-- sysdeps/unix/sysv/linux/setrlimit64.c | 7 +++++-- sysdeps/unix/sysv/linux/signalfd.c | 11 ++++++++--- sysdeps/unix/sysv/linux/statfs64.c | 13 +++++++++---- 7 files changed, 46 insertions(+), 20 deletions(-) diff --git a/sysdeps/unix/sysv/linux/eventfd.c b/sysdeps/unix/sysv/linux/eventfd.c index 55406bb..87d78ca 100644 --- a/sysdeps/unix/sysv/linux/eventfd.c +++ b/sysdeps/unix/sysv/linux/eventfd.c @@ -25,11 +25,15 @@ int eventfd (unsigned int count, int flags) { #ifdef __NR_eventfd2 - int res = INLINE_SYSCALL (eventfd2, 2, count, flags); # ifndef __ASSUME_EVENTFD2 - if (res != -1 || errno != ENOSYS) -# endif + INTERNAL_SYSCALL_DECL (err); + int res = INTERNAL_SYSCALL (eventfd2, err, 2, count, flags); + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)) + || INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS) return res; +# else + return INLINE_SYSCALL (eventfd2, 2, count, flags); +# endif #endif #ifndef __ASSUME_EVENTFD2 diff --git a/sysdeps/unix/sysv/linux/fstatfs64.c b/sysdeps/unix/sysv/linux/fstatfs64.c index af83830..eb21d42 100644 --- a/sysdeps/unix/sysv/linux/fstatfs64.c +++ b/sysdeps/unix/sysv/linux/fstatfs64.c @@ -35,12 +35,16 @@ __fstatfs64 (int fd, struct statfs64 *buf) if (! __no_statfs64) # endif { - int result = INLINE_SYSCALL (fstatfs64, 3, fd, sizeof (*buf), buf); - # if __ASSUME_STATFS64 == 0 - if (result == 0 || errno != ENOSYS) -# endif + INTERNAL_SYSCALL_DECL (err); + int result = INTERNAL_SYSCALL (fstatfs64, err, 3, fd, + sizeof (*buf), buf); + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)) + || INTERNAL_SYSCALL_ERRNO (result, err) != ENOSYS) return result; +# else + return INLINE_SYSCALL (fstatfs64, 3, fd, sizeof (*buf), buf); +# endif # if __ASSUME_STATFS64 == 0 __no_statfs64 = 1; diff --git a/sysdeps/unix/sysv/linux/getrlimit64.c b/sysdeps/unix/sysv/linux/getrlimit64.c index 100ba62..cca1265 100644 --- a/sysdeps/unix/sysv/linux/getrlimit64.c +++ b/sysdeps/unix/sysv/linux/getrlimit64.c @@ -30,8 +30,11 @@ __getrlimit64 (enum __rlimit_resource resource, struct rlimit64 *rlimits) return INLINE_SYSCALL (prlimit64, 4, 0, resource, NULL, rlimits); #else # ifdef __NR_prlimit64 - int res = INLINE_SYSCALL (prlimit64, 4, 0, resource, NULL, rlimits); - if (res == 0 || errno != ENOSYS) + INTERNAL_SYSCALL_DECL (err); + int res = INTERNAL_SYSCALL (prlimit64, err, 4, 0, resource, NULL, + rlimits); + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)) + || INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS) return res; # endif struct rlimit rlimits32; diff --git a/sysdeps/unix/sysv/linux/lxstat64.c b/sysdeps/unix/sysv/linux/lxstat64.c index 5d0c051..8afddfd 100644 --- a/sysdeps/unix/sysv/linux/lxstat64.c +++ b/sysdeps/unix/sysv/linux/lxstat64.c @@ -30,8 +30,10 @@ int ___lxstat64 (int vers, const char *name, struct stat64 *buf) { - int result; - result = INLINE_SYSCALL (lstat64, 2, name, buf); + INTERNAL_SYSCALL_DECL (err); + int result = INTERNAL_SYSCALL (lstat64, err, 2, name, buf); + if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err))) + return INLINE_SYSCALL_ERROR_RETURN (INTERNAL_SYSCALL_ERRNO (result, err)); #if defined _HAVE_STAT64___ST_INO && __ASSUME_ST_INO_64_BIT == 0 if (__builtin_expect (!result, 1) && buf->__st_ino != (__ino_t) buf->st_ino) buf->st_ino = buf->__st_ino; diff --git a/sysdeps/unix/sysv/linux/setrlimit64.c b/sysdeps/unix/sysv/linux/setrlimit64.c index 17f95cb..33e1500 100644 --- a/sysdeps/unix/sysv/linux/setrlimit64.c +++ b/sysdeps/unix/sysv/linux/setrlimit64.c @@ -33,8 +33,11 @@ setrlimit64 (resource, rlimits) return INLINE_SYSCALL (prlimit64, 4, 0, resource, rlimits, NULL); #else # ifdef __NR_prlimit64 - int res = INLINE_SYSCALL (prlimit64, 4, 0, resource, rlimits, NULL); - if (res == 0 || errno != ENOSYS) + INTERNAL_SYSCALL_DECL (err); + int res = INTERNAL_SYSCALL (prlimit64, err, 4, 0, resource, rlimits, + NULL); + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)) + || INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS) return res; # endif struct rlimit rlimits32; diff --git a/sysdeps/unix/sysv/linux/signalfd.c b/sysdeps/unix/sysv/linux/signalfd.c index 1e242a4..b3c541c 100644 --- a/sysdeps/unix/sysv/linux/signalfd.c +++ b/sysdeps/unix/sysv/linux/signalfd.c @@ -26,11 +26,16 @@ int signalfd (int fd, const sigset_t *mask, int flags) { #ifdef __NR_signalfd4 - int res = INLINE_SYSCALL (signalfd4, 4, fd, mask, _NSIG / 8, flags); # ifndef __ASSUME_SIGNALFD4 - if (res != -1 || errno != ENOSYS) -# endif + INTERNAL_SYSCALL_DECL (err); + int res = INTERNAL_SYSCALL (signalfd4, err, 4, fd, mask, _NSIG / 8, + flags); + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (res, err)) + || INTERNAL_SYSCALL_ERRNO (res, err) != ENOSYS) return res; +# else + return INLINE_SYSCALL (signalfd4, 4, fd, mask, _NSIG / 8, flags); +# endif #endif #ifndef __ASSUME_SIGNALFD4 diff --git a/sysdeps/unix/sysv/linux/statfs64.c b/sysdeps/unix/sysv/linux/statfs64.c index ac5c33f..fdd1667 100644 --- a/sysdeps/unix/sysv/linux/statfs64.c +++ b/sysdeps/unix/sysv/linux/statfs64.c @@ -37,12 +37,17 @@ __statfs64 (const char *file, struct statfs64 *buf) if (! __no_statfs64) # endif { - int result = INLINE_SYSCALL (statfs64, 3, file, sizeof (*buf), buf); - # if __ASSUME_STATFS64 == 0 - if (result == 0 || errno != ENOSYS) -# endif + INTERNAL_SYSCALL_DECL (err); + int result = INTERNAL_SYSCALL (statfs64, err, 3, file, + sizeof (*buf), buf); + + if (!__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result, err)) + || INTERNAL_SYSCALL_ERRNO (result, err) != ENOSYS) return result; +# else + return INLINE_SYSCALL (statfs64, 3, file, sizeof (*buf), buf); +# endif # if __ASSUME_STATFS64 == 0 __no_statfs64 = 1;