From patchwork Fri Nov 13 16:58:15 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 41049 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 7E24339450C5; Fri, 13 Nov 2020 16:58:53 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7E24339450C5 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1605286733; bh=6ndiiTgWbSNFjMkOWrqLqUpG6Ns/X4G+JiCUr8I+2wI=; 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=heb7KTd+CPLdjha/QWBElhC0NoSc2tPKzOozXwjGZH3S7z0d4jFSx8V190nE6oD2i l8NlqchvDPe8kDFss5RBFI19/mNQC5XieuX7XI5Id9Kz8NBzyJByx1TsXE+DHVPPrQ lu5xeZz4B+9Whctu9cRppb+iP4FY+T0yldRHPCBE= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-qk1-x741.google.com (mail-qk1-x741.google.com [IPv6:2607:f8b0:4864:20::741]) by sourceware.org (Postfix) with ESMTPS id 452783945047 for ; Fri, 13 Nov 2020 16:58:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 452783945047 Received: by mail-qk1-x741.google.com with SMTP id 199so9386699qkg.9 for ; Fri, 13 Nov 2020 08:58:49 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=6ndiiTgWbSNFjMkOWrqLqUpG6Ns/X4G+JiCUr8I+2wI=; b=d4dpL/+/UDYrRxVBcOYCSCoTElYV7dnHXYnmkbnr/f+YYDT5zOkVz1m/pouFONtUOu ZUZnUCgBB2jvCUsiT9qylQ6qUJEriDIXANqihwSvd1SSDZWbmJzQvOfJnTCEffuCWuXH 7mzFRLHl0GENQozbGSxYKQOLWO/sGG8UPUfqMnFSkx9/4kXabuhjFbSMmb99PTEP0dh0 B8Eg3wMivO4zUT2tLFVSl/+5L8GVSRlzVdP/74d8GS848LhTJ3huw10Nfov/L+bdz7yr Nxrq2lqDkihLxoc+zPn2W254lVNZlDzhaPLqtOkh0TqQlff4nV9GFJFWh16hT1b/losM WAgw== X-Gm-Message-State: AOAM530s8SIhnQ1jajznr7XXrUblhaiUSVMMnHXYRzeyrjP5oKKvBbEd Kclj71kjdlHtnxxsOl6GZBHC3oEaX6MFCQ== X-Google-Smtp-Source: ABdhPJwUYPq7jrqk5YGOjtfTNYFW4GnYUbvtrAXA52pJJv7sG1TMhbzo3/WD4a+FNvvT7wTsJsqk0w== X-Received: by 2002:a37:2cc2:: with SMTP id s185mr2905288qkh.118.1605286723363; Fri, 13 Nov 2020 08:58:43 -0800 (PST) Received: from localhost.localdomain ([177.194.48.209]) by smtp.googlemail.com with ESMTPSA id s16sm7363931qkg.5.2020.11.13.08.58.42 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 13 Nov 2020 08:58:42 -0800 (PST) To: libc-alpha@sourceware.org Subject: [PATCH v2 01/23] linux: Remove INTERNAL_SYSCALL_ERRNO Date: Fri, 13 Nov 2020 13:58:15 -0300 Message-Id: <20201113165837.121629-2-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20201113165837.121629-1-adhemerval.zanella@linaro.org> References: <20201113165837.121629-1-adhemerval.zanella@linaro.org> MIME-Version: 1.0 X-Spam-Status: No, score=-13.9 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.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) 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@sourceware.org Sender: "Libc-alpha" All architectures now returns the error code on the INTERNAL_SYSCALL value and follow the Linux de-facto ABI (error are signaled with a value between -4096UL and -1UL). This make the INTERNAL_SYSCALL_ERRNO superflous and some implementations already checks for either values different than 0 or for an specific errno in the failure case. Checked on x86_64-linux-gnu and powerpc64le-linux-gnu. --- nptl/allocatestack.c | 2 +- nptl/nptl-init.c | 2 +- nptl/pthread_cancel.c | 2 +- nptl/pthread_getaffinity.c | 2 +- nptl/pthread_mutex_trylock.c | 3 +-- nptl/pthread_setaffinity.c | 2 +- nptl/pthread_sigmask.c | 2 +- sysdeps/nptl/lowlevellock-futex.h | 2 +- sysdeps/unix/sysv/linux/createthread.c | 2 +- sysdeps/unix/sysv/linux/dl-write.c | 5 +---- sysdeps/unix/sysv/linux/fcntl_nocancel.c | 3 +-- sysdeps/unix/sysv/linux/libc_fatal.c | 3 +-- sysdeps/unix/sysv/linux/mq_unlink.c | 7 +++---- sysdeps/unix/sysv/linux/not-errno.h | 4 ++-- sysdeps/unix/sysv/linux/personality.c | 10 +--------- sysdeps/unix/sysv/linux/posix_fadvise.c | 4 +--- sysdeps/unix/sysv/linux/posix_fadvise64.c | 4 +--- sysdeps/unix/sysv/linux/posix_fallocate.c | 4 ++-- sysdeps/unix/sysv/linux/posix_fallocate64.c | 4 ++-- sysdeps/unix/sysv/linux/posix_madvise.c | 3 +-- sysdeps/unix/sysv/linux/pthread_kill.c | 3 +-- sysdeps/unix/sysv/linux/pthread_sigqueue.c | 3 +-- sysdeps/unix/sysv/linux/s390/s390-32/posix_fadvise64.c | 4 +--- sysdeps/unix/sysv/linux/shmat.c | 2 +- sysdeps/unix/sysv/linux/sysdep-vdso.h | 4 ++-- sysdeps/unix/sysv/linux/sysdep.h | 5 +---- sysdeps/unix/sysv/linux/timer_create.c | 2 +- sysdeps/unix/sysv/linux/times.c | 2 +- 28 files changed, 34 insertions(+), 61 deletions(-) diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 4b45f8c884..a9e9d39354 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -1174,7 +1174,7 @@ __nptl_setxid (struct xid_command *cmdp) int error = 0; if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result))) { - error = INTERNAL_SYSCALL_ERRNO (result); + error = -result; __set_errno (error); result = -1; } diff --git a/nptl/nptl-init.c b/nptl/nptl-init.c index 4aa1231bec..cbf9cda989 100644 --- a/nptl/nptl-init.c +++ b/nptl/nptl-init.c @@ -191,7 +191,7 @@ sighandler_setxid (int sig, siginfo_t *si, void *ctx) __xidcmd->id[1], __xidcmd->id[2]); int error = 0; if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (result))) - error = INTERNAL_SYSCALL_ERRNO (result); + error = -result; __nptl_setxid_error (__xidcmd, error); /* Reset the SETXID flag. */ diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c index 88c1ab8f6a..7daf4f8c15 100644 --- a/nptl/pthread_cancel.c +++ b/nptl/pthread_cancel.c @@ -70,7 +70,7 @@ __pthread_cancel (pthread_t th) int val = INTERNAL_SYSCALL_CALL (tgkill, pid, pd->tid, SIGCANCEL); if (INTERNAL_SYSCALL_ERROR_P (val)) - result = INTERNAL_SYSCALL_ERRNO (val); + result = -val; break; } diff --git a/nptl/pthread_getaffinity.c b/nptl/pthread_getaffinity.c index 6ebd1ded2d..ffeb878c7c 100644 --- a/nptl/pthread_getaffinity.c +++ b/nptl/pthread_getaffinity.c @@ -34,7 +34,7 @@ __pthread_getaffinity_np (pthread_t th, size_t cpusetsize, cpu_set_t *cpuset) int res = INTERNAL_SYSCALL_CALL (sched_getaffinity, pd->tid, MIN (INT_MAX, cpusetsize), cpuset); if (INTERNAL_SYSCALL_ERROR_P (res)) - return INTERNAL_SYSCALL_ERRNO (res); + return -res; /* Clean the rest of the memory the kernel didn't do. */ memset ((char *) cpuset + res, '\0', cpusetsize - res); diff --git a/nptl/pthread_mutex_trylock.c b/nptl/pthread_mutex_trylock.c index 2130f52529..5c294a3eea 100644 --- a/nptl/pthread_mutex_trylock.c +++ b/nptl/pthread_mutex_trylock.c @@ -301,8 +301,7 @@ __pthread_mutex_trylock (pthread_mutex_t *mutex) __lll_private_flag (FUTEX_TRYLOCK_PI, private), 0, 0); - if (INTERNAL_SYSCALL_ERROR_P (e) - && INTERNAL_SYSCALL_ERRNO (e) == EWOULDBLOCK) + if (INTERNAL_SYSCALL_ERROR_P (e) && e == -EWOULDBLOCK) { /* The kernel has not yet finished the mutex owner death. We do not need to ensure ordering wrt another memory diff --git a/nptl/pthread_setaffinity.c b/nptl/pthread_setaffinity.c index b0bd90c324..aaaa4f0194 100644 --- a/nptl/pthread_setaffinity.c +++ b/nptl/pthread_setaffinity.c @@ -34,7 +34,7 @@ __pthread_setaffinity_new (pthread_t th, size_t cpusetsize, cpuset); return (INTERNAL_SYSCALL_ERROR_P (res) - ? INTERNAL_SYSCALL_ERRNO (res) + ? -res : 0); } versioned_symbol (libpthread, __pthread_setaffinity_new, diff --git a/nptl/pthread_sigmask.c b/nptl/pthread_sigmask.c index 7b65ae1f27..1d6d753af4 100644 --- a/nptl/pthread_sigmask.c +++ b/nptl/pthread_sigmask.c @@ -42,7 +42,7 @@ __pthread_sigmask (int how, const sigset_t *newmask, sigset_t *oldmask) oldmask, __NSIG_BYTES); return (INTERNAL_SYSCALL_ERROR_P (result) - ? INTERNAL_SYSCALL_ERRNO (result) + ? -result : 0); } libc_hidden_def (__pthread_sigmask) diff --git a/sysdeps/nptl/lowlevellock-futex.h b/sysdeps/nptl/lowlevellock-futex.h index 2209ca76a1..dd36997021 100644 --- a/sysdeps/nptl/lowlevellock-futex.h +++ b/sysdeps/nptl/lowlevellock-futex.h @@ -70,7 +70,7 @@ long int __ret = INTERNAL_SYSCALL (futex, nargs, futexp, op, \ __VA_ARGS__); \ (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (__ret)) \ - ? -INTERNAL_SYSCALL_ERRNO (__ret) : 0); \ + ? __ret : 0); \ }) /* For most of these macros, the return value is never really used. diff --git a/sysdeps/unix/sysv/linux/createthread.c b/sysdeps/unix/sysv/linux/createthread.c index 6588893ba5..01cf2ff42a 100644 --- a/sysdeps/unix/sysv/linux/createthread.c +++ b/sysdeps/unix/sysv/linux/createthread.c @@ -132,7 +132,7 @@ create_thread (struct pthread *pd, const struct pthread_attr *attr, pid_t pid = __getpid (); INTERNAL_SYSCALL_CALL (tgkill, pid, pd->tid, SIGCANCEL); - return INTERNAL_SYSCALL_ERRNO (res); + return -res; } } diff --git a/sysdeps/unix/sysv/linux/dl-write.c b/sysdeps/unix/sysv/linux/dl-write.c index 1c6298fb41..cce5a55e68 100644 --- a/sysdeps/unix/sysv/linux/dl-write.c +++ b/sysdeps/unix/sysv/linux/dl-write.c @@ -23,8 +23,5 @@ ssize_t _dl_write (int fd, const void *buffer, size_t length) { - long int r = INTERNAL_SYSCALL_CALL (write, fd, buffer, length); - if (INTERNAL_SYSCALL_ERROR_P (r)) - r = - INTERNAL_SYSCALL_ERRNO (r); - return r; + return INTERNAL_SYSCALL_CALL (write, fd, buffer, length); } diff --git a/sysdeps/unix/sysv/linux/fcntl_nocancel.c b/sysdeps/unix/sysv/linux/fcntl_nocancel.c index ed9211001f..1bf3030f75 100644 --- a/sysdeps/unix/sysv/linux/fcntl_nocancel.c +++ b/sysdeps/unix/sysv/linux/fcntl_nocancel.c @@ -56,8 +56,7 @@ __fcntl64_nocancel_adjusted (int fd, int cmd, void *arg) if (!INTERNAL_SYSCALL_ERROR_P (res)) return fex.type == F_OWNER_GID ? -fex.pid : fex.pid; - return INLINE_SYSCALL_ERROR_RETURN_VALUE - (INTERNAL_SYSCALL_ERRNO (res)); + return INLINE_SYSCALL_ERROR_RETURN_VALUE (-res); } return INLINE_SYSCALL_CALL (fcntl64, fd, cmd, (void *) arg); diff --git a/sysdeps/unix/sysv/linux/libc_fatal.c b/sysdeps/unix/sysv/linux/libc_fatal.c index 6f568eed51..e9e0fde23d 100644 --- a/sysdeps/unix/sysv/linux/libc_fatal.c +++ b/sysdeps/unix/sysv/linux/libc_fatal.c @@ -27,8 +27,7 @@ writev_for_fatal (int fd, const struct iovec *iov, size_t niov, size_t total) ssize_t cnt; do cnt = INTERNAL_SYSCALL_CALL (writev, fd, iov, niov); - while (INTERNAL_SYSCALL_ERROR_P (cnt) - && INTERNAL_SYSCALL_ERRNO (cnt) == EINTR); + while (INTERNAL_SYSCALL_ERROR_P (cnt) && cnt == -EINTR); return cnt == total; } #define WRITEV_FOR_FATAL writev_for_fatal diff --git a/sysdeps/unix/sysv/linux/mq_unlink.c b/sysdeps/unix/sysv/linux/mq_unlink.c index 85fb5d0951..ed7858dc9d 100644 --- a/sysdeps/unix/sysv/linux/mq_unlink.c +++ b/sysdeps/unix/sysv/linux/mq_unlink.c @@ -32,10 +32,9 @@ mq_unlink (const char *name) return just EACCES. */ if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (ret))) { - ret = INTERNAL_SYSCALL_ERRNO (ret); - if (ret == EPERM) - ret = EACCES; - return INLINE_SYSCALL_ERROR_RETURN_VALUE (ret); + if (ret == -EPERM) + ret = -EACCES; + return INLINE_SYSCALL_ERROR_RETURN_VALUE (-ret); } return ret; diff --git a/sysdeps/unix/sysv/linux/not-errno.h b/sysdeps/unix/sysv/linux/not-errno.h index 394dabeb93..fc0eda09d9 100644 --- a/sysdeps/unix/sysv/linux/not-errno.h +++ b/sysdeps/unix/sysv/linux/not-errno.h @@ -32,7 +32,7 @@ __access_noerrno (const char *pathname, int mode) res = INTERNAL_SYSCALL_CALL (faccessat, AT_FDCWD, pathname, mode); #endif if (INTERNAL_SYSCALL_ERROR_P (res)) - return INTERNAL_SYSCALL_ERRNO (res); + return -res; return 0; } @@ -42,6 +42,6 @@ __kill_noerrno (pid_t pid, int sig) int res; res = INTERNAL_SYSCALL_CALL (kill, pid, sig); if (INTERNAL_SYSCALL_ERROR_P (res)) - return INTERNAL_SYSCALL_ERRNO (res); + return -res; return 0; } diff --git a/sysdeps/unix/sysv/linux/personality.c b/sysdeps/unix/sysv/linux/personality.c index e45fffa1c2..75f9d0adb2 100644 --- a/sysdeps/unix/sysv/linux/personality.c +++ b/sysdeps/unix/sysv/linux/personality.c @@ -35,14 +35,6 @@ __personality (unsigned long persona) persona = (unsigned int) persona; #endif - long int ret = INTERNAL_SYSCALL_CALL (personality, persona); - - /* Starting with kernel commit v2.6.29-6609-g11d06b2, the personality syscall - never fails. However, 32-bit kernels might flag valid values as errors, so - we need to reverse the error setting. We can't use the raw result as some - arches split the return/error values. */ - if (__glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (ret))) - ret = -INTERNAL_SYSCALL_ERRNO (ret); - return ret; + return INTERNAL_SYSCALL_CALL (personality, persona); } weak_alias (__personality, personality) diff --git a/sysdeps/unix/sysv/linux/posix_fadvise.c b/sysdeps/unix/sysv/linux/posix_fadvise.c index bada96b697..1191ab3db5 100644 --- a/sysdeps/unix/sysv/linux/posix_fadvise.c +++ b/sysdeps/unix/sysv/linux/posix_fadvise.c @@ -60,8 +60,6 @@ posix_fadvise (int fd, off_t offset, off_t len, int advise) SYSCALL_LL (len), advise); # endif # endif - if (INTERNAL_SYSCALL_ERROR_P (ret)) - return INTERNAL_SYSCALL_ERRNO (ret); - return 0; + return INTERNAL_SYSCALL_ERROR_P (ret) ? -ret : 0; } #endif /* __OFF_T_MATCHES_OFF64_T */ diff --git a/sysdeps/unix/sysv/linux/posix_fadvise64.c b/sysdeps/unix/sysv/linux/posix_fadvise64.c index 7323c82a07..e6f2d5c1fd 100644 --- a/sysdeps/unix/sysv/linux/posix_fadvise64.c +++ b/sysdeps/unix/sysv/linux/posix_fadvise64.c @@ -49,9 +49,7 @@ __posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise) __ALIGNMENT_ARG SYSCALL_LL64 (offset), SYSCALL_LL64 (len), advise); #endif - if (!INTERNAL_SYSCALL_ERROR_P (ret)) - return 0; - return INTERNAL_SYSCALL_ERRNO (ret); + return INTERNAL_SYSCALL_ERROR_P (ret) ? -ret : 0; } /* The type of the len argument was changed from size_t to off_t in diff --git a/sysdeps/unix/sysv/linux/posix_fallocate.c b/sysdeps/unix/sysv/linux/posix_fallocate.c index 7238b00038..87532668cd 100644 --- a/sysdeps/unix/sysv/linux/posix_fallocate.c +++ b/sysdeps/unix/sysv/linux/posix_fallocate.c @@ -30,7 +30,7 @@ posix_fallocate (int fd, __off_t offset, __off_t len) SYSCALL_LL (offset), SYSCALL_LL (len)); if (! INTERNAL_SYSCALL_ERROR_P (res)) return 0; - if (INTERNAL_SYSCALL_ERRNO (res) != EOPNOTSUPP) - return INTERNAL_SYSCALL_ERRNO (res); + if (res != -EOPNOTSUPP) + return -res; return internal_fallocate (fd, offset, len); } diff --git a/sysdeps/unix/sysv/linux/posix_fallocate64.c b/sysdeps/unix/sysv/linux/posix_fallocate64.c index 2de63ac277..517fee14f4 100644 --- a/sysdeps/unix/sysv/linux/posix_fallocate64.c +++ b/sysdeps/unix/sysv/linux/posix_fallocate64.c @@ -32,8 +32,8 @@ __posix_fallocate64_l64 (int fd, __off64_t offset, __off64_t len) SYSCALL_LL64 (offset), SYSCALL_LL64 (len)); if (! INTERNAL_SYSCALL_ERROR_P (res)) return 0; - if (INTERNAL_SYSCALL_ERRNO (res) != EOPNOTSUPP) - return INTERNAL_SYSCALL_ERRNO (res); + if (res != -EOPNOTSUPP) + return -res; return internal_fallocate64 (fd, offset, len); } libc_hidden_def (__posix_fallocate64_l64) diff --git a/sysdeps/unix/sysv/linux/posix_madvise.c b/sysdeps/unix/sysv/linux/posix_madvise.c index 0e49f3b7ac..5fe2e5f653 100644 --- a/sysdeps/unix/sysv/linux/posix_madvise.c +++ b/sysdeps/unix/sysv/linux/posix_madvise.c @@ -31,6 +31,5 @@ posix_madvise (void *addr, size_t len, int advice) if (advice == POSIX_MADV_DONTNEED) return 0; - int result = INTERNAL_SYSCALL_CALL (madvise, addr, len, advice); - return INTERNAL_SYSCALL_ERRNO (result); + return -INTERNAL_SYSCALL_CALL (madvise, addr, len, advice); } diff --git a/sysdeps/unix/sysv/linux/pthread_kill.c b/sysdeps/unix/sysv/linux/pthread_kill.c index 4dfe08ffcd..defdeaecac 100644 --- a/sysdeps/unix/sysv/linux/pthread_kill.c +++ b/sysdeps/unix/sysv/linux/pthread_kill.c @@ -51,7 +51,6 @@ __pthread_kill (pthread_t threadid, int signo) pid_t pid = __getpid (); int val = INTERNAL_SYSCALL_CALL (tgkill, pid, tid, signo); - return (INTERNAL_SYSCALL_ERROR_P (val) - ? INTERNAL_SYSCALL_ERRNO (val) : 0); + return INTERNAL_SYSCALL_ERROR_P (val) ? -val : 0; } strong_alias (__pthread_kill, pthread_kill) diff --git a/sysdeps/unix/sysv/linux/pthread_sigqueue.c b/sysdeps/unix/sysv/linux/pthread_sigqueue.c index 4b32be2d64..fbbd9fee20 100644 --- a/sysdeps/unix/sysv/linux/pthread_sigqueue.c +++ b/sysdeps/unix/sysv/linux/pthread_sigqueue.c @@ -63,8 +63,7 @@ pthread_sigqueue (pthread_t threadid, int signo, const union sigval value) /* We have a special syscall to do the work. */ int val = INTERNAL_SYSCALL_CALL (rt_tgsigqueueinfo, pid, tid, signo, &info); - return (INTERNAL_SYSCALL_ERROR_P (val) - ? INTERNAL_SYSCALL_ERRNO (val) : 0); + return INTERNAL_SYSCALL_ERROR_P (val) ? -val : 0; #else return ENOSYS; #endif diff --git a/sysdeps/unix/sysv/linux/s390/s390-32/posix_fadvise64.c b/sysdeps/unix/sysv/linux/s390/s390-32/posix_fadvise64.c index b556a6caae..6199589307 100644 --- a/sysdeps/unix/sysv/linux/s390/s390-32/posix_fadvise64.c +++ b/sysdeps/unix/sysv/linux/s390/s390-32/posix_fadvise64.c @@ -43,9 +43,7 @@ __posix_fadvise64_l64 (int fd, off64_t offset, off64_t len, int advise) parameters.len = len; parameters.advise = advise; int ret = INTERNAL_SYSCALL_CALL (fadvise64_64, ¶meters); - if (!INTERNAL_SYSCALL_ERROR_P (ret)) - return 0; - return INTERNAL_SYSCALL_ERRNO (ret); + return INTERNAL_SYSCALL_ERROR_P (ret) ? -ret : 0; } #include diff --git a/sysdeps/unix/sysv/linux/shmat.c b/sysdeps/unix/sysv/linux/shmat.c index 89df350d84..d5a65c06c1 100644 --- a/sysdeps/unix/sysv/linux/shmat.c +++ b/sysdeps/unix/sysv/linux/shmat.c @@ -36,7 +36,7 @@ shmat (int shmid, const void *shmaddr, int shmflg) resultvar = INTERNAL_SYSCALL_CALL (ipc, IPCOP_shmat, shmid, shmflg, &raddr, shmaddr); if (INTERNAL_SYSCALL_ERROR_P (resultvar)) - return (void *) INLINE_SYSCALL_ERROR_RETURN_VALUE (INTERNAL_SYSCALL_ERRNO (resultvar)); + return (void *) INLINE_SYSCALL_ERROR_RETURN_VALUE (-resultvar); return raddr; #endif diff --git a/sysdeps/unix/sysv/linux/sysdep-vdso.h b/sysdeps/unix/sysv/linux/sysdep-vdso.h index a9215494dc..88db076184 100644 --- a/sysdeps/unix/sysv/linux/sysdep-vdso.h +++ b/sysdeps/unix/sysv/linux/sysdep-vdso.h @@ -38,7 +38,7 @@ sc_ret = INTERNAL_VSYSCALL_CALL (vdsop, nr, ##args); \ if (!INTERNAL_SYSCALL_ERROR_P (sc_ret)) \ goto out; \ - if (INTERNAL_SYSCALL_ERRNO (sc_ret) != ENOSYS) \ + if (sc_ret != -ENOSYS) \ goto iserr; \ } \ \ @@ -46,7 +46,7 @@ if (INTERNAL_SYSCALL_ERROR_P (sc_ret)) \ { \ iserr: \ - __set_errno (INTERNAL_SYSCALL_ERRNO (sc_ret)); \ + __set_errno (-sc_ret); \ sc_ret = -1L; \ } \ out: \ diff --git a/sysdeps/unix/sysv/linux/sysdep.h b/sysdeps/unix/sysv/linux/sysdep.h index 71ecc19cd5..a47f47526d 100644 --- a/sysdeps/unix/sysv/linux/sysdep.h +++ b/sysdeps/unix/sysv/linux/sysdep.h @@ -43,13 +43,10 @@ ({ \ long int sc_ret = INTERNAL_SYSCALL (name, nr, args); \ __glibc_unlikely (INTERNAL_SYSCALL_ERROR_P (sc_ret)) \ - ? SYSCALL_ERROR_LABEL (INTERNAL_SYSCALL_ERRNO (sc_ret)) \ + ? SYSCALL_ERROR_LABEL (-sc_ret) \ : sc_ret; \ }) -#undef INTERNAL_SYSCALL_ERRNO -#define INTERNAL_SYSCALL_ERRNO(val) (-(val)) - /* Set error number and return -1. A target may choose to return the internal function, __syscall_error, which sets errno and returns -1. We use -1l, instead of -1, so that it can be casted to (void *). */ diff --git a/sysdeps/unix/sysv/linux/timer_create.c b/sysdeps/unix/sysv/linux/timer_create.c index 18fb00c6e6..d8289d1dc7 100644 --- a/sysdeps/unix/sysv/linux/timer_create.c +++ b/sysdeps/unix/sysv/linux/timer_create.c @@ -127,7 +127,7 @@ timer_create (clockid_t clock_id, struct sigevent *evp, timer_t *timerid) if (INTERNAL_SYSCALL_ERROR_P (res)) { free (newp); - __set_errno (INTERNAL_SYSCALL_ERRNO (res)); + __set_errno (-res); return -1; } diff --git a/sysdeps/unix/sysv/linux/times.c b/sysdeps/unix/sysv/linux/times.c index e3db9cb400..b5eb6404c9 100644 --- a/sysdeps/unix/sysv/linux/times.c +++ b/sysdeps/unix/sysv/linux/times.c @@ -25,7 +25,7 @@ __times (struct tms *buf) { clock_t ret = INTERNAL_SYSCALL_CALL (times, buf); if (INTERNAL_SYSCALL_ERROR_P (ret) - && __glibc_unlikely (INTERNAL_SYSCALL_ERRNO (ret) == EFAULT) + && __glibc_unlikely (ret == -EFAULT) && buf) { /* This might be an error or not. For architectures which have no