From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-out.m-online.net (mail-out.m-online.net [212.18.0.9]) by sourceware.org (Postfix) with ESMTPS id 785BC3857C7F for ; Tue, 6 Oct 2020 09:42:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 785BC3857C7F 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 4C5CF36cMrz1r6nC; Tue, 6 Oct 2020 11:42:47 +0200 (CEST) Received: from localhost (dynscan1.mnet-online.de [192.168.6.70]) by mail.m-online.net (Postfix) with ESMTP id 4C5CF34gttz1sM9L; Tue, 6 Oct 2020 11:42:47 +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 j1pRO-DRuYtD; Tue, 6 Oct 2020 11:42:44 +0200 (CEST) X-Auth-Info: AaisvFP+zP1QlSvbu+A/Agfkqrze6tbX+1bOxX4QIzU= Received: from jawa (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; Tue, 6 Oct 2020 11:42:44 +0200 (CEST) Date: Tue, 6 Oct 2020 11:42:24 +0200 From: Lukasz Majewski To: Adhemerval Zanella Cc: Joseph Myers , Paul Eggert , Alistair Francis , Arnd Bergmann , Alistair Francis , GNU C Library , Florian Weimer , Carlos O'Donell , Stepan Golosunov , Andreas Schwab , Zack Weinberg , Jeff Law Subject: Re: [RFC PATCH v1] y2038: nptl: Convert pthread_mutex_{clock|timed}lock to support 64 bit Message-ID: <20201006114224.610fb928@jawa> In-Reply-To: References: <20200923122502.28172-1-lukma@denx.de> Organization: denx.de X-Mailer: Claws Mail 3.17.4 (GTK+ 2.24.32; x86_64-pc-linux-gnu) MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha512; boundary="Sig_/apHzvkuQ.yWUnNcqy1ZEtGt"; protocol="application/pgp-signature" X-Spam-Status: No, score=-16.2 required=5.0 tests=BAYES_00, GIT_PATCH_0, KAM_DMARC_STATUS, KAM_LAZY_DOMAIN_SECURITY, 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: , X-List-Received-Date: Tue, 06 Oct 2020 09:42:53 -0000 --Sig_/apHzvkuQ.yWUnNcqy1ZEtGt Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: quoted-printable Hi Adhemerval, > On 23/09/2020 09:25, Lukasz Majewski wrote: > > The pthread_mutex_clocklock and pthread_mutex_timedlock have been > > converted to support 64 bit time. > >=20 > > This change uses: > > - New __futex_clocklock64 function (instead of lll_clocklock) > > - New __futex_clocklock_wait64 (instead of lll_timedwait) > >=20 > > from ./sysdeps/nptl/futex-helpers.c and > >=20 > > - New futex_lock_pi64 defined in sysdeps/nptl/futex-internal.h > >=20 > > The pthread_mutex_{clock|timed}lock only accepts absolute time. > > Moreover, there is no need to check for NULL passed as *abstime > > pointer to the syscalls as those calls have exported symbols marked > > with __nonull attribute for abstime. > >=20 > > Some architectures - namely x86, powerpc and s390 - do support lock > > elision. For those - adjustments have been made in arch specific > > elision-*.c files to use __futex_clocklock64 instead of > > lll_clocklock. The __lll_lock_elision (aliased to > > __lll_clocklock_elision in e.g. > > sysdeps/unix/sysv/linux/s390/elision-timed.c) just uses, in this > > patch provided, __futex_clocklock64. > >=20 > > For systems with __TIMESIZE !=3D 64 && __WORDSIZE =3D=3D 32: > > - Conversions between 64 bit time to 32 bit are necessary > > - Redirection to pthread_mutex_{clock|timed}lock will provide > > support for 64 bit time > >=20 > > Build tests: > > ./src/scripts/build-many-glibcs.py glibcs =20 >=20 > Some comments below. Thank you for your feedback. >=20 > > --- > > nptl/pthreadP.h | 9 +++ > > nptl/pthread_mutex_timedlock.c | 67 > > +++++++++++------ sysdeps/nptl/futex-internal.c | > > 71 +++++++++++++++++++ sysdeps/nptl/futex-internal.h > > | 52 ++++++++++++++ .../unix/sysv/linux/powerpc/elision-timed.c > > | 5 +- .../unix/sysv/linux/powerpc/lowlevellock.h | 2 +- > > sysdeps/unix/sysv/linux/s390/elision-timed.c | 5 +- > > sysdeps/unix/sysv/linux/s390/lowlevellock.h | 2 +- > > sysdeps/unix/sysv/linux/x86/elision-timed.c | 5 +- > > sysdeps/unix/sysv/linux/x86/lowlevellock.h | 2 +- > > 10 files changed, 191 insertions(+), 29 deletions(-) > >=20 > > diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h > > index 5bcc8a2db5..710b21e890 100644 > > --- a/nptl/pthreadP.h > > +++ b/nptl/pthreadP.h > > @@ -468,6 +468,8 @@ extern int __pthread_cond_wait (pthread_cond_t > > *cond, pthread_mutex_t *mutex); # define > > __pthread_rwlock_clockwrlock64 __pthread_rwlock_clockwrlock # > > define __pthread_rwlock_timedrdlock64 __pthread_rwlock_timedrdlock > > # define __pthread_rwlock_timedwrlock64 > > __pthread_rwlock_timedwrlock +# define __pthread_mutex_clocklock64 > > __pthread_mutex_clocklock +# define __pthread_mutex_timedlock64 > > __pthread_mutex_timedlock #else extern int __pthread_clockjoin_np64 > > (pthread_t threadid, void **thread_return, clockid_t clockid, =20 >=20 > Ok. >=20 > > @@ -499,6 +501,13 @@ libpthread_hidden_proto > > (__pthread_rwlock_timedrdlock64) extern int > > __pthread_rwlock_timedwrlock64 (pthread_rwlock_t *rwlock, const > > struct __timespec64 *abstime); libpthread_hidden_proto > > (__pthread_rwlock_timedwrlock64) +extern int > > __pthread_mutex_clocklock64 (pthread_mutex_t *mutex, > > + clockid_t clockid, > > + const struct __timespec64 > > *abstime); +libpthread_hidden_proto (__pthread_mutex_clocklock64) > > +extern int __pthread_mutex_timedlock64 (pthread_mutex_t *mutex, > > + const struct __timespec64 > > *abstime); +libpthread_hidden_proto (__pthread_mutex_timedlock64) > > #endif > > =20 > > extern int __pthread_cond_timedwait (pthread_cond_t *cond, =20 >=20 > Ok. >=20 > > diff --git a/nptl/pthread_mutex_timedlock.c > > b/nptl/pthread_mutex_timedlock.c index 8ae814b984..424dff3cae 100644 > > --- a/nptl/pthread_mutex_timedlock.c > > +++ b/nptl/pthread_mutex_timedlock.c > > @@ -31,7 +31,7 @@ > > =20 > > #ifndef lll_clocklock_elision > > #define lll_clocklock_elision(futex, adapt_count, clockid, > > abstime, private) \ > > - lll_clocklock (futex, clockid, abstime, private) > > + __futex_clocklock64 (futex, clockid, abstime, private) > > #endif > > =20 > > #ifndef lll_trylock_elision =20 >=20 > Ok. >=20 > > @@ -45,7 +45,7 @@ > > int > > __pthread_mutex_clocklock_common (pthread_mutex_t *mutex, > > clockid_t clockid, > > - const struct timespec *abstime) > > + const struct __timespec64 > > *abstime) { > > int oldval; > > pid_t id =3D THREAD_GETMEM (THREAD_SELF, tid); > > @@ -76,8 +76,8 @@ __pthread_mutex_clocklock_common (pthread_mutex_t > > *mutex, } > > =20 > > /* We have to get the mutex. */ > > - result =3D lll_clocklock (mutex->__data.__lock, clockid, > > abstime, > > - PTHREAD_MUTEX_PSHARED (mutex)); > > + result =3D __futex_clocklock64 (mutex->__data.__lock, clockid, > > abstime, > > + PTHREAD_MUTEX_PSHARED (mutex)); > > =20 > > if (result !=3D 0) > > goto out; =20 >=20 > Ok. >=20 > > @@ -99,8 +99,8 @@ __pthread_mutex_clocklock_common (pthread_mutex_t > > *mutex, FORCE_ELISION (mutex, goto elision); > > simple: > > /* Normal mutex. */ > > - result =3D lll_clocklock (mutex->__data.__lock, clockid, > > abstime, > > - PTHREAD_MUTEX_PSHARED (mutex)); > > + result =3D __futex_clocklock64 (mutex->__data.__lock, clockid, > > abstime, > > + PTHREAD_MUTEX_PSHARED (mutex)); > > break; > > =20 > > case PTHREAD_MUTEX_TIMED_ELISION_NP: =20 >=20 > Ok. >=20 > > @@ -125,9 +125,9 @@ __pthread_mutex_clocklock_common > > (pthread_mutex_t *mutex, { > > if (cnt++ >=3D max_cnt) > > { > > - result =3D lll_clocklock (mutex->__data.__lock, > > - clockid, abstime, > > - PTHREAD_MUTEX_PSHARED > > (mutex)); > > + result =3D __futex_clocklock64 > > (mutex->__data.__lock, > > + clockid, abstime, > > + > > PTHREAD_MUTEX_PSHARED (mutex)); break; > > } > > atomic_spin_nop (); =20 >=20 > Ok. >=20 > > @@ -378,8 +378,8 @@ __pthread_mutex_clocklock_common > > (pthread_mutex_t *mutex, int private =3D (robust > > ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex) > > : PTHREAD_MUTEX_PSHARED (mutex)); > > - int e =3D futex_lock_pi ((unsigned int *) > > &mutex->__data.__lock, > > - abstime, private); > > + int e =3D futex_lock_pi64 ((unsigned int *) > > &mutex->__data.__lock, > > + abstime, private); > > if (e =3D=3D ETIMEDOUT) > > return ETIMEDOUT; > > else if (e =3D=3D ESRCH || e =3D=3D EDEADLK) =20 >=20 > The only usage of futex_lock_pi64 is here, so intead to force a cast > just change the futex_lock_pi64 prototype to accept a 'int *' as > argument for the futex. Ok. >=20 > > @@ -394,8 +394,8 @@ __pthread_mutex_clocklock_common > > (pthread_mutex_t *mutex, /* Delay the thread until the timeout is > > reached. Then return ETIMEDOUT. */ > > do > > - e =3D lll_timedwait (&(int){0}, 0, clockid, > > abstime, > > - private); > > + e =3D __futex_clocklock_wait64 (&(int){0}, 0, > > clockid, abstime, > > + private); > > while (e !=3D ETIMEDOUT); > > return ETIMEDOUT; > > } =20 >=20 > Ok. >=20 > > @@ -543,10 +543,10 @@ __pthread_mutex_clocklock_common > > (pthread_mutex_t *mutex, goto failpp; > > } > > =20 > > - struct timespec rt; > > + struct __timespec64 rt; > > =20 > > /* Get the current time. */ > > - __clock_gettime (CLOCK_REALTIME, &rt); > > + __clock_gettime64 (CLOCK_REALTIME, &rt); > > =20 > > /* Compute relative timeout. */ > > rt.tv_sec =3D abstime->tv_sec - rt.tv_sec; =20 >=20 > Ok. >=20 > > @@ -599,9 +599,9 @@ __pthread_mutex_clocklock_common > > (pthread_mutex_t *mutex, } > > =20 > > int > > -__pthread_mutex_clocklock (pthread_mutex_t *mutex, > > - clockid_t clockid, > > - const struct timespec *abstime) > > +__pthread_mutex_clocklock64 (pthread_mutex_t *mutex, > > + clockid_t clockid, > > + const struct __timespec64 *abstime) > > { > > if (__glibc_unlikely (!lll_futex_supported_clockid (clockid))) > > return EINVAL; =20 >=20 > Ok. >=20 > > @@ -609,13 +609,40 @@ __pthread_mutex_clocklock (pthread_mutex_t > > *mutex, LIBC_PROBE (mutex_clocklock_entry, 3, mutex, clockid, > > abstime); return __pthread_mutex_clocklock_common (mutex, clockid, > > abstime); } > > -weak_alias (__pthread_mutex_clocklock, pthread_mutex_clocklock) > > + > > +#if __TIMESIZE !=3D 64 > > +libpthread_hidden_def (__pthread_mutex_clocklock64) > > =20 > > int > > -__pthread_mutex_timedlock (pthread_mutex_t *mutex, > > +__pthread_mutex_clocklock (pthread_mutex_t *mutex, > > + clockid_t clockid, > > const struct timespec *abstime) > > +{ > > + struct __timespec64 ts64 =3D valid_timespec_to_timespec64 > > (*abstime); + > > + return __pthread_mutex_clocklock64 (mutex, clockid, &ts64); > > +} > > +#endif > > +weak_alias (__pthread_mutex_clocklock, pthread_mutex_clocklock) > > + > > +int > > +__pthread_mutex_timedlock64 (pthread_mutex_t *mutex, > > + const struct __timespec64 *abstime) > > { > > LIBC_PROBE (mutex_timedlock_entry, 2, mutex, abstime); > > return __pthread_mutex_clocklock_common (mutex, CLOCK_REALTIME, > > abstime); } > > + > > +#if __TIMESIZE !=3D 64 > > +libpthread_hidden_def (__pthread_mutex_timedlock64) > > + > > +int > > +__pthread_mutex_timedlock (pthread_mutex_t *mutex, > > + const struct timespec *abstime) > > +{ > > + struct __timespec64 ts64 =3D valid_timespec_to_timespec64 > > (*abstime); + > > + return __pthread_mutex_timedlock64 (mutex, &ts64); > > +} > > +#endif > > weak_alias (__pthread_mutex_timedlock, pthread_mutex_timedlock) =20 >=20 > Ok. >=20 > > diff --git a/sysdeps/nptl/futex-internal.c > > b/sysdeps/nptl/futex-internal.c index 3211b4c94f..2e1df42e98 100644 > > --- a/sysdeps/nptl/futex-internal.c > > +++ b/sysdeps/nptl/futex-internal.c > > @@ -167,3 +167,74 @@ __futex_abstimed_wait64 (unsigned int* > > futex_word, unsigned int expected, futex_fatal_error (); > > } > > } > > + > > +int > > +__futex_clocklock_wait64 (int *futex, int val, clockid_t clockid, > > + const struct __timespec64 *abstime, int > > private) +{ > > + struct __timespec64 ts, *tsp =3D NULL; > > + > > + if (abstime !=3D NULL) > > + { > > + /* Reject invalid timeouts. */ > > + if (! valid_nanoseconds (abstime->tv_nsec)) > > + return EINVAL; > > + > > + /* Get the current time. This can only fail if clockid is > > not valid. */ =20 >=20 > Double space after period. I've double checked this and there are two spaces between . and *. >=20 > > + if (__glibc_unlikely (__clock_gettime64 (clockid, &ts) !=3D 0)) > > + return EINVAL; > > + > > + /* Compute relative timeout. */ > > + ts.tv_sec =3D abstime->tv_sec - ts.tv_sec; > > + ts.tv_nsec =3D abstime->tv_nsec - ts.tv_nsec; > > + if (ts.tv_nsec < 0) > > + { > > + ts.tv_nsec +=3D 1000000000; > > + --ts.tv_sec; > > + } > > + > > + if (ts.tv_sec < 0) > > + return ETIMEDOUT; > > + > > + tsp =3D &ts; > > + } > > + > > + int err =3D INTERNAL_SYSCALL_CALL (futex_time64, futex, > > __lll_private_flag > > + (FUTEX_WAIT, private), val, > > tsp); =20 >=20 > As indicated by Andreas, don't split function calls before the paren. So it shall be: int err =3D INTERNAL_SYSCALL_CALL (futex_time64, futex, __lll_private_flag (FUTEX_WAIT,private), val, tsp); >=20 > > +#ifndef __ASSUME_TIME64_SYSCALLS > > + if (err =3D=3D -ENOSYS) > > + { > > + if (tsp !=3D NULL && ! in_time_t_range (tsp->tv_sec)) > > + return EOVERFLOW; > > + > > + struct timespec ts32; > > + if (tsp !=3D NULL) > > + ts32 =3D valid_timespec64_to_timespec (*tsp); =20 >=20 > Ok. =20 >=20 > > + > > + err =3D INTERNAL_SYSCALL_CALL (futex, futex, > > + __lll_private_flag (FUTEX_WAIT, > > private), > > + val, tsp !=3D NULL ? &ts32 : > > NULL); > > + } > > +#endif > > + > > + return -err; > > +} > > + > > +int > > +__futex_clocklock64 (int futex, clockid_t clockid, > > + const struct __timespec64 *abstime, int > > private) +{ > > + int *futexp =3D &futex; =20 >=20 >=20 > This is incorrect I am not sure why it hasn't triggered any > regression in your testing.=20 Please note that this is the RFC patch as I was not sure about the "elision" related changes. > The 'lll_clocklock' and the > '__lll_clocklock' works because they are macros and expands the the > futex *address* on the same TU. Yes, you are of course right here. Thanks for spotting it. > Passing the futex *value* and using > the address of the local variable uses the different *address* than > the intended one. Yes, correct. I've adjusted the code accordingly. >=20 > > + int err =3D 0; > > + > > + if (__glibc_unlikely (atomic_compare_and_exchange_bool_acq > > (futexp, 1, 0))) > > + { > > + while (atomic_exchange_acq (futexp, 2) !=3D 0) > > + { > > + err =3D __futex_clocklock_wait64 (futexp, 2, clockid, > > abstime, private); > > + if (err =3D=3D EINVAL || err =3D=3D ETIMEDOUT || err =3D=3D > > EOVERFLOW) > > + break; > > + } > > + } > > + return err; > > +} =20 >=20 > I think the idea of the current lll_clocklock macro is to inline the > atomic fast path and I think we should keep the same strategy to > avoid possible performance regressions. Ok. >=20 > So in a short: >=20 > 1. Move __futex_clocklock64 implementation to futex-internal.h and > change its prototype to receive the futex address (similar to > __lll_clocklock). >=20 > static inline int > __futex_clocklock64 (int *futex, clockid_t clockid, > const struct __timespec64 *abstime, int > private) {=20 > int err =3D 0; > if (__glibc_unlikely (atomic_compare_and_exchange_bool_acq > (futex, 1, 0))) {=20 > while (atomic_exchange_acq (futex, 2) !=3D 0) > {=20 > err =3D __futex_clocklock_wait64 (futex, 2, clockid, > abstime, private); if (err =3D=3D EINVAL || err =3D=3D ETIMEDOUT || err = =3D=3D > EOVERFLOW) break; > } > } > return err; > } >=20 > 2. Call __futex_clocklock64 nptl/pthread_mutex_timedlock.c using > the expected signature, i.e, by passing the lock address > (&mutex->__data.__lock). >=20 > 3. Adapt the elision-timed.c implementations from x86, powerpc, and > s390 to do the same. >=20 Ok. >=20 > > diff --git a/sysdeps/nptl/futex-internal.h > > b/sysdeps/nptl/futex-internal.h index 1ba0d61938..e84024591d 100644 > > --- a/sysdeps/nptl/futex-internal.h > > +++ b/sysdeps/nptl/futex-internal.h > > @@ -437,6 +437,51 @@ futex_lock_pi (unsigned int *futex_word, const > > struct timespec *abstime, } > > } > > =20 > > +static __always_inline int > > +futex_lock_pi64 (unsigned int *futex_word, const struct > > __timespec64 *abstime, > > + int private) > > +{ > > + int err =3D INTERNAL_SYSCALL_CALL (futex_time64, futex_word, > > + __lll_private_flag > > + (FUTEX_LOCK_PI, private), 0, > > abstime); =20 >=20 > Same as before, don't split function calls before the paren. >=20 > > +#ifndef __ASSUME_TIME64_SYSCALLS > > + if (err =3D=3D -ENOSYS) > > + { > > + if (abstime !=3D NULL && ! in_time_t_range (abstime->tv_sec)) > > + return EOVERFLOW; > > + > > + struct timespec ts32; > > + if (abstime !=3D NULL) > > + ts32 =3D valid_timespec64_to_timespec (*abstime); > > + > > + err =3D INTERNAL_SYSCALL_CALL (futex, futex_word, > > __lll_private_flag > > + (FUTEX_LOCK_PI, private), 0, > > + abstime !=3D NULL ? &ts32 : NULL); > > + } =20 >=20 > Ok. >=20 > > +#endif > > + switch (err) > > + { > > + case 0: > > + case -EAGAIN: > > + case -EINTR: > > + case -ETIMEDOUT: > > + case -ESRCH: > > + case -EDEADLK: > > + case -EINVAL: /* This indicates either state corruption or > > that the kernel > > + found a waiter on futex address which is > > waiting via > > + FUTEX_WAIT or FUTEX_WAIT_BITSET. This is > > reported on > > + some futex_lock_pi usage > > (pthread_mutex_timedlock for > > + instance). */ > > + return -err; > > + > > + case -EFAULT: /* Must have been caused by a glibc or > > application bug. */ > > + case -ENOSYS: /* Must have been caused by a glibc bug. */ > > + /* No other errors are documented at this time. */ > > + default: > > + futex_fatal_error (); > > + } > > +} > > + > > /* Wakes the top priority waiter that called a futex_lock_pi > > operation on the futex. > > =20 >=20 > Ok. >=20 > > @@ -535,4 +580,11 @@ __futex_abstimed_wait64 (unsigned int* > > futex_word, unsigned int expected, const struct __timespec64* > > abstime, int private) attribute_hidden; > > =20 > > +int > > +__futex_clocklock64 (int futex, clockid_t clockid, > > + const struct __timespec64 *abstime, int > > private); + > > +int > > +__futex_clocklock_wait64 (int *futex, int val, clockid_t clockid, > > + const struct __timespec64 *abstime, int > > private); #endif /* futex-internal.h */ =20 >=20 > As before the function prototype is not really correct. This has been fixed. Thanks for pointing this out. >=20 > > diff --git a/sysdeps/unix/sysv/linux/powerpc/elision-timed.c > > b/sysdeps/unix/sysv/linux/powerpc/elision-timed.c index > > 5c2b500f1d..bab826dcba 100644 --- > > a/sysdeps/unix/sysv/linux/powerpc/elision-timed.c +++ > > b/sysdeps/unix/sysv/linux/powerpc/elision-timed.c @@ -19,10 +19,11 > > @@ #include > > #include > > #include "lowlevellock.h" > > +#include "sysdeps/nptl/futex-internal.h" > > =20 > > #define __lll_lock_elision __lll_clocklock_elision > > -#define EXTRAARG clockid_t clockid, const struct timespec *t, > > +#define EXTRAARG clockid_t clockid, const struct __timespec64 *t, > > #undef LLL_LOCK > > -#define LLL_LOCK(a, b) lll_clocklock(a, clockid, t, b) > > +#define LLL_LOCK(a, b) __futex_clocklock64 (a, clockid, t, b) > > =20 > > #include "elision-lock.c" > > diff --git a/sysdeps/unix/sysv/linux/powerpc/lowlevellock.h > > b/sysdeps/unix/sysv/linux/powerpc/lowlevellock.h index > > 53ada4a04b..fe7a5d2da5 100644 --- > > a/sysdeps/unix/sysv/linux/powerpc/lowlevellock.h +++ > > b/sysdeps/unix/sysv/linux/powerpc/lowlevellock.h @@ -24,7 +24,7 @@ > > /* Transactional lock elision definitions. */ > > extern int __lll_clocklock_elision > > (int *futex, short *adapt_count, > > - clockid_t clockid, const struct timespec *timeout, int private) > > + clockid_t clockid, const struct __timespec64 *timeout, int > > private) attribute_hidden; > > =20 > > #define lll_clocklock_elision(futex, adapt_count, clockid, > > timeout, private) \ diff --git > > a/sysdeps/unix/sysv/linux/s390/elision-timed.c > > b/sysdeps/unix/sysv/linux/s390/elision-timed.c index > > 83d6a83d8d..4f8174c5a9 100644 --- > > a/sysdeps/unix/sysv/linux/s390/elision-timed.c +++ > > b/sysdeps/unix/sysv/linux/s390/elision-timed.c @@ -19,8 +19,9 @@ > > #include #include > > #include > > +#include "sysdeps/nptl/futex-internal.h" > > #define __lll_lock_elision __lll_clocklock_elision > > -#define EXTRAARG clockid_t clockid, const struct timespec *t, > > +#define EXTRAARG clockid_t clockid, const struct __timespec64 *t, > > #undef LLL_LOCK > > -#define LLL_LOCK(a, b) lll_clocklock(a, clockid, t, b) > > +#define LLL_LOCK(a, b) __futex_clocklock64 (a, clockid, t, b) > > #include "elision-lock.c" > > diff --git a/sysdeps/unix/sysv/linux/s390/lowlevellock.h > > b/sysdeps/unix/sysv/linux/s390/lowlevellock.h index > > c790077a79..27bc23ff24 100644 --- > > a/sysdeps/unix/sysv/linux/s390/lowlevellock.h +++ > > b/sysdeps/unix/sysv/linux/s390/lowlevellock.h @@ -24,7 +24,7 @@ > > /* Transactional lock elision definitions. */ > > extern int __lll_clocklock_elision > > (int *futex, short *adapt_count, > > - clockid_t clockid, const struct timespec *timeout, int private) > > + clockid_t clockid, const struct __timespec64 *timeout, int > > private) attribute_hidden; > > =20 > > # define lll_clocklock_elision(futex, adapt_count, clockid, > > timeout, private) \ diff --git > > a/sysdeps/unix/sysv/linux/x86/elision-timed.c > > b/sysdeps/unix/sysv/linux/x86/elision-timed.c index > > 87e5c788c6..03212d8cd9 100644 --- > > a/sysdeps/unix/sysv/linux/x86/elision-timed.c +++ > > b/sysdeps/unix/sysv/linux/x86/elision-timed.c @@ -19,8 +19,9 @@ > > #include #include > > #include "lowlevellock.h" > > +#include "sysdeps/nptl/futex-internal.h" > > #define __lll_lock_elision __lll_clocklock_elision > > -#define EXTRAARG clockid_t clockid, const struct timespec *t, > > +#define EXTRAARG clockid_t clockid, const struct __timespec64 *t, > > #undef LLL_LOCK > > -#define LLL_LOCK(a, b) lll_clocklock (a, clockid, t, b) > > +#define LLL_LOCK(a, b) __futex_clocklock64 (a, clockid, t, b) > > #include "elision-lock.c" > > diff --git a/sysdeps/unix/sysv/linux/x86/lowlevellock.h > > b/sysdeps/unix/sysv/linux/x86/lowlevellock.h index > > 27d62c9301..d0ea71b105 100644 --- > > a/sysdeps/unix/sysv/linux/x86/lowlevellock.h +++ > > b/sysdeps/unix/sysv/linux/x86/lowlevellock.h @@ -84,7 +84,7 @@ > > __lll_cas_lock (int *futex)=20 > > extern int __lll_clocklock_elision (int *futex, short *adapt_count, > > clockid_t clockid, > > - const struct timespec *timeout, > > + const struct __timespec64 > > *timeout, int private) attribute_hidden; > > =20 > > #define lll_clocklock_elision(futex, adapt_count, clockid, > > timeout, private) \=20 Best regards, Lukasz Majewski -- DENX Software Engineering GmbH, Managing Director: Wolfgang Denk HRB 165235 Munich, Office: Kirchenstr.5, D-82194 Groebenzell, Germany Phone: (+49)-8142-66989-59 Fax: (+49)-8142-66989-80 Email: lukma@denx.de --Sig_/apHzvkuQ.yWUnNcqy1ZEtGt Content-Type: application/pgp-signature Content-Description: OpenPGP digital signature -----BEGIN PGP SIGNATURE----- iQEzBAEBCgAdFiEEgAyFJ+N6uu6+XupJAR8vZIA0zr0FAl98PAAACgkQAR8vZIA0 zr3a+gf8DRTYN4jdSaIoRmeUQoRS3TWdzqEp35AUc5bIj/F05ZhGKt+buK4MhvTR HuFFy74InkJEeIrHGu8stMaLLLLJ/l17avoRwRgKW+C5WX7CBWhJ4I+Yjlt0H65O OaALNGMmGyl5bXwXH8A5yVJgWbkCMsDQV5oKQguMGZ+H4rq78rcesxTI/+I4odFS QwHDwcOds3gr1gp+40b8ufUYD1l83b/7n1uumb+zmHgwp3c26mKjjaN8GWxFyeem 3RCGKecWF0P4/P0uaB8HjLTgM+xH34rbB91+R0VzG70a0DJo2ExvYPShzsGzlRbd OUiHyn/Tw2hnTCD/m4rNDhpqEKgoQw== =zZaI -----END PGP SIGNATURE----- --Sig_/apHzvkuQ.yWUnNcqy1ZEtGt--