From patchwork Wed Jul 22 07:30:02 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lukasz Majewski X-Patchwork-Id: 40141 X-Patchwork-Delegate: l.majewski@majess.pl 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 CF4EE3890429; Wed, 22 Jul 2020 07:30:25 +0000 (GMT) X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-out.m-online.net (mail-out.m-online.net [212.18.0.9]) by sourceware.org (Postfix) with ESMTPS id CEE073890411 for ; Wed, 22 Jul 2020 07:30:22 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org CEE073890411 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=denx.de Authentication-Results: sourceware.org; spf=none smtp.mailfrom=lukma@denx.de Received: from frontend01.mail.m-online.net (unknown [192.168.8.182]) by mail-out.m-online.net (Postfix) with ESMTP id 4BBRvH4r1sz1qsbF; Wed, 22 Jul 2020 09:30:19 +0200 (CEST) Received: from localhost (dynscan1.mnet-online.de [192.168.6.70]) by mail.m-online.net (Postfix) with ESMTP id 4BBRvH3Wt8z1qv2q; Wed, 22 Jul 2020 09:30:19 +0200 (CEST) X-Virus-Scanned: amavisd-new at mnet-online.de Received: from mail.mnet-online.de ([192.168.8.182]) by localhost (dynscan1.mail.m-online.net [192.168.6.70]) (amavisd-new, port 10024) with ESMTP id SOhSwYgoCa8W; Wed, 22 Jul 2020 09:30:17 +0200 (CEST) X-Auth-Info: IYjQbx+PaQPbgBjuNOYnWfhe4BGNthuc7D6sjtpCbXc= Received: from localhost.localdomain (85-222-111-42.dynamic.chello.pl [85.222.111.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.mnet-online.de (Postfix) with ESMTPSA; Wed, 22 Jul 2020 09:30:17 +0200 (CEST) From: Lukasz Majewski To: Joseph Myers , Paul Eggert , Adhemerval Zanella Subject: [PATCH] y2038: nptl: Convert pthread_{clock|timed}join_np to support 64 bit time Date: Wed, 22 Jul 2020 09:30:02 +0200 Message-Id: <20200722073002.1854-1-lukma@denx.de> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 X-Spam-Status: No, score=-18.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_LAZY_DOMAIN_SECURITY, KAM_SHORT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, 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: , Cc: Florian Weimer , GNU C Library , Andreas Schwab , Stepan Golosunov , Alistair Francis Errors-To: libc-alpha-bounces@sourceware.org Sender: "Libc-alpha" The pthread_clockjoin_np and pthread_timedjoin_np have been converted to support 64 bit time. This change introduces new futex_timed_wait_cancel64 function in ./sysdeps/nptl/futex-internal.h, which uses futex_time64 where possible and tries to replace low-level preprocessor macros from lowlevellock-futex.h The pthread_{timed|clock}join_np only accept absolute time. Moreover, there is no need to check for NULL passed as *abstime pointer as clockwait_tid() always passes struct __timespec64. For systems with __TIMESIZE != 64 && __WORDSIZE == 32: - Conversions between 64 bit time to 32 bit are necessary - Redirection to __pthread_{clock|timed}join_np64 will provide support for 64 bit time Build tests: ./src/scripts/build-many-glibcs.py glibcs Run-time tests: - Run specific tests on ARM/x86 32bit systems (qemu): https://github.com/lmajewski/meta-y2038 and run tests: https://github.com/lmajewski/y2038-tests/commits/master Above tests were performed with Y2038 redirection applied as well as without to test the proper usage of both __ntp_gettimex64 and __ntp_gettimex. --- nptl/pthreadP.h | 16 +++++++++++++++- nptl/pthread_clockjoin.c | 19 ++++++++++++++++--- nptl/pthread_join_common.c | 19 +++++++++++-------- nptl/pthread_timedjoin.c | 18 ++++++++++++++++-- sysdeps/nptl/futex-internal.h | 31 +++++++++++++++++++++++++++++++ 5 files changed, 89 insertions(+), 14 deletions(-) diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h index 6f94d6be31..99713c8447 100644 --- a/nptl/pthreadP.h +++ b/nptl/pthreadP.h @@ -458,6 +458,20 @@ extern int __pthread_cond_init (pthread_cond_t *cond, libc_hidden_proto (__pthread_cond_init) extern int __pthread_cond_signal (pthread_cond_t *cond); extern int __pthread_cond_wait (pthread_cond_t *cond, pthread_mutex_t *mutex); + +#if __TIMESIZE == 64 +# define __pthread_clockjoin_np64 __pthread_clockjoin_np +# define __pthread_timedjoin_np64 __pthread_timedjoin_np +#else +extern int __pthread_clockjoin_np64 (pthread_t threadid, void **thread_return, + clockid_t clockid, + const struct __timespec64 *abstime); +libc_hidden_proto (__pthread_clockjoin_np64) +extern int __pthread_timedjoin_np64 (pthread_t threadid, void **thread_return, + const struct __timespec64 *abstime); +libc_hidden_proto (__pthread_timedjoin_np64) +#endif + extern int __pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); @@ -488,7 +502,7 @@ extern int __pthread_enable_asynccancel (void) attribute_hidden; extern void __pthread_disable_asynccancel (int oldtype) attribute_hidden; extern void __pthread_testcancel (void); extern int __pthread_clockjoin_ex (pthread_t, void **, clockid_t, - const struct timespec *, bool) + const struct __timespec64 *, bool) attribute_hidden; extern int __pthread_sigmask (int, const sigset_t *, sigset_t *); libc_hidden_proto (__pthread_sigmask); diff --git a/nptl/pthread_clockjoin.c b/nptl/pthread_clockjoin.c index a3e7f37e3b..3cd780f688 100644 --- a/nptl/pthread_clockjoin.c +++ b/nptl/pthread_clockjoin.c @@ -16,14 +16,27 @@ License along with the GNU C Library; if not, see . */ +#include #include "pthreadP.h" int -__pthread_clockjoin_np (pthread_t threadid, void **thread_return, - clockid_t clockid, - const struct timespec *abstime) +__pthread_clockjoin_np64 (pthread_t threadid, void **thread_return, + clockid_t clockid, const struct __timespec64 *abstime) { return __pthread_clockjoin_ex (threadid, thread_return, clockid, abstime, true); } + +#if __TIMESIZE != 64 +libc_hidden_def (__pthread_clockjoin_np64) + +int +__pthread_clockjoin_np (pthread_t threadid, void **thread_return, + clockid_t clockid, const struct timespec *abstime) +{ + struct __timespec64 ts64 = valid_timespec_to_timespec64 (*abstime); + + return __pthread_clockjoin_np64 (threadid, thread_return, clockid, &ts64); +} +#endif weak_alias (__pthread_clockjoin_np, pthread_clockjoin_np) diff --git a/nptl/pthread_join_common.c b/nptl/pthread_join_common.c index a96ceafde4..67d8e2b780 100644 --- a/nptl/pthread_join_common.c +++ b/nptl/pthread_join_common.c @@ -20,6 +20,7 @@ #include #include #include +#include static void cleanup (void *arg) @@ -37,9 +38,11 @@ cleanup (void *arg) afterwards. The kernel up to version 3.16.3 does not use the private futex operations for futex wake-up when the clone terminates. */ static int -clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime) +clockwait_tid (pid_t *tidp, clockid_t clockid, + const struct __timespec64 *abstime) { pid_t tid; + int ret; if (! valid_nanoseconds (abstime->tv_nsec)) return EINVAL; @@ -47,11 +50,11 @@ clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime) /* Repeat until thread terminated. */ while ((tid = *tidp) != 0) { - struct timespec rt; + struct __timespec64 rt; /* Get the current time. This can only fail if clockid is invalid. */ - if (__glibc_unlikely (__clock_gettime (clockid, &rt))) + if (__glibc_unlikely (__clock_gettime64 (clockid, &rt))) return EINVAL; /* Compute relative timeout. */ @@ -70,9 +73,9 @@ clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime) /* If *tidp == tid, wait until thread terminates or the wait times out. The kernel up to version 3.16.3 does not use the private futex operations for futex wake-up when the clone terminates. */ - if (lll_futex_timed_wait_cancel (tidp, tid, &rt, LLL_SHARED) - == -ETIMEDOUT) - return ETIMEDOUT; + ret = futex_timed_wait_cancel64 (tidp, tid, &rt, LLL_SHARED); + if (ret == -ETIMEDOUT || ret == -EOVERFLOW) + return -ret; } return 0; @@ -80,8 +83,8 @@ clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime) int __pthread_clockjoin_ex (pthread_t threadid, void **thread_return, - clockid_t clockid, - const struct timespec *abstime, bool block) + clockid_t clockid, + const struct __timespec64 *abstime, bool block) { struct pthread *pd = (struct pthread *) threadid; diff --git a/nptl/pthread_timedjoin.c b/nptl/pthread_timedjoin.c index dd7038dcf7..6164ae7060 100644 --- a/nptl/pthread_timedjoin.c +++ b/nptl/pthread_timedjoin.c @@ -16,13 +16,27 @@ License along with the GNU C Library; if not, see . */ +#include #include "pthreadP.h" int -__pthread_timedjoin_np (pthread_t threadid, void **thread_return, - const struct timespec *abstime) +__pthread_timedjoin_np64 (pthread_t threadid, void **thread_return, + const struct __timespec64 *abstime) { return __pthread_clockjoin_ex (threadid, thread_return, CLOCK_REALTIME, abstime, true); } + +#if __TIMESIZE != 64 +libc_hidden_def (__pthread_timedjoin_np64) + +int +__pthread_timedjoin_np (pthread_t threadid, void **thread_return, + const struct timespec *abstime) +{ + struct __timespec64 ts64 = valid_timespec_to_timespec64 (*abstime); + + return __pthread_timedjoin_np64 (threadid, thread_return, &ts64); +} +#endif weak_alias (__pthread_timedjoin_np, pthread_timedjoin_np) diff --git a/sysdeps/nptl/futex-internal.h b/sysdeps/nptl/futex-internal.h index d622122ddc..e0a539ae9e 100644 --- a/sysdeps/nptl/futex-internal.h +++ b/sysdeps/nptl/futex-internal.h @@ -467,4 +467,35 @@ futex_unlock_pi (unsigned int *futex_word, int private) } } +#ifndef __NR_futex_time64 +# define __NR_futex_time64 __NR_futex +#endif + +static __always_inline int +futex_timed_wait_cancel64 (pid_t *tidp, pid_t tid, + struct __timespec64 *timeout, int private) +{ + int oldtype = CANCEL_ASYNC (); + long int ret = INTERNAL_SYSCALL (futex_time64, 4, tidp, + __lll_private_flag (FUTEX_WAIT, private), + tid, timeout); +#ifndef __ASSUME_TIME64_SYSCALLS + if (ret == -ENOSYS) + { + struct timespec ts32; + if (! in_time_t_range (timeout->tv_sec)) + { + CANCEL_RESET (oldtype); + return -EOVERFLOW; + } + ts32 = valid_timespec64_to_timespec (*timeout); + + ret = INTERNAL_SYSCALL (futex, 4, tidp, + __lll_private_flag (FUTEX_WAIT, private), + tid, &ts32); + } +#endif + CANCEL_RESET (oldtype); + return ret; +} #endif /* futex-internal.h */