mirror of git://sourceware.org/git/glibc.git
nptl: Reinstate pthread_timedjoin_np as a cancellation point (BZ#24215)
Patch ce7eb0e903 ("nptl: Cleanup cancellation macros") changed the
join sequence for internal common __pthread_timedjoin_ex to use the
new macro lll_wait_tid. The idea was this macro would issue the
cancellable futex operation depending whether the timeout is used or
not. However if a timeout is used, __lll_timedwait_tid is called and
it is not a cancellable entrypoint.
This patch fixes it by simplifying the code in various ways:
- Instead of adding the cancellation handling on __lll_timedwait_tid,
it moves the generic implementation to pthread_join_common.c (called
now timedwait_tid with some fixes to use the correct type for pid).
- The llvm_wait_tid macro is removed, along with its replication on
x86_64, i686, and sparc arch-specific lowlevellock.h.
- sparc32 __lll_timedwait_tid is also removed, since the code is similar
to generic one.
- x86_64 and i386 provides arch-specific __lll_timedwait_tid which is
also removed since they are similar in functionality to generic C code
and there is no indication it is better than compiler generated code.
New tests, tst-join8 and tst-join9, are provided to check if
pthread_timedjoin_np acts as a cancellation point.
Checked on x86_64-linux-gnu, i686-linux-gnu, sparcv9-linux-gnu, and
aarch64-linux-gnu.
[BZ #24215]
* nptl/Makefile (lpthread-routines): Remove lll_timedwait_tid.
(tests): Add tst-join8 tst-join9.
* nptl/lll_timedwait_tid.c: Remove file.
* sysdeps/sparc/sparc32/lll_timedwait_tid.c: Likewise.
* sysdeps/unix/sysv/linux/i386/lll_timedwait_tid.c: Likewise.
* sysdeps/sysv/linux/x86_64/lll_timedwait_tid.c: Likewise.
* nptl/pthread_join_common.c (timedwait_tid): New function.
(__pthread_timedjoin_ex): Act as cancellation entrypoint is block
is set.
* nptl/tst-join5.c (thread_join): New function.
(tf1, tf2, do_test): Use libsupport and add pthread_timedjoin_np
check.
* nptl/tst-join8.c: New file.
* nptl/tst-join9.c: Likewise.
* sysdeps/nptl/lowlevellock-futex.h (lll_futex_wait_cancel,
lll_futex_timed_wait_cancel): Add generic macros.
* sysdeps/nptl/lowlevellock.h (__lll_timedwait_tid, lll_wait_tid):
Remove definitions.
* sysdeps/unix/sysv/linux/i386/lowlevellock.h: Likewise.
* sysdeps/unix/sysv/linux/sparc/lowlevellock.h: Likewise.
* sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
* sysdeps/sparc/sparc32/lowlevellock.c (__lll_timedwait_tid):
Remove function.
* sysdeps/unix/sysv/linux/i386/lowlevellock.S (__lll_timedwait_tid):
Likewise.
* sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: Likewise.
* sysdeps/unix/sysv/linux/lowlevellock-futex.h
(lll_futex_timed_wait_cancel): New macro.
This commit is contained in:
Adhemerval Zanella
parent
20d0195c71
commit
eb76e5b465
32
ChangeLog
32
ChangeLog
|
|
@ -1,3 +1,35 @@
|
|||
2019-02-14 Adhemerval Zanella <adhemerval.zanella@linaro.org>
|
||||
|
||||
[BZ #2421]
|
||||
* nptl/Makefile (lpthread-routines): Remove lll_timedwait_tid.
|
||||
(tests): Add tst-join8 tst-join9.
|
||||
* nptl/lll_timedwait_tid.c: Remove file.
|
||||
* sysdeps/sparc/sparc32/lll_timedwait_tid.c: Likewise.
|
||||
* sysdeps/unix/sysv/linux/i386/lll_timedwait_tid.c: Likewise.
|
||||
* sysdeps/sysv/linux/x86_64/lll_timedwait_tid.c: Likewise.
|
||||
* nptl/pthread_join_common.c (timedwait_tid): New function.
|
||||
(__pthread_timedjoin_ex): Act as cancellation entrypoint is block
|
||||
is set.
|
||||
* nptl/tst-join5.c (thread_join): New function.
|
||||
(tf1, tf2, do_test): Use libsupport and add pthread_timedjoin_np
|
||||
check.
|
||||
* nptl/tst-join8.c: New file.
|
||||
* nptl/tst-join9.c: Likewise.
|
||||
* sysdeps/nptl/lowlevellock-futex.h (lll_futex_wait_cancel,
|
||||
lll_futex_timed_wait_cancel): Add generic macros.
|
||||
* sysdeps/nptl/lowlevellock.h (__lll_timedwait_tid, lll_wait_tid):
|
||||
Remove definitions.
|
||||
* sysdeps/unix/sysv/linux/i386/lowlevellock.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/sparc/lowlevellock.h: Likewise.
|
||||
* sysdeps/unix/sysv/linux/x86_64/lowlevellock.h: Likewise.
|
||||
* sysdeps/sparc/sparc32/lowlevellock.c (__lll_timedwait_tid):
|
||||
Remove function.
|
||||
* sysdeps/unix/sysv/linux/i386/lowlevellock.S (__lll_timedwait_tid):
|
||||
Likewise.
|
||||
* sysdeps/unix/sysv/linux/x86_64/lowlevellock.S: Likewise.
|
||||
* sysdeps/unix/sysv/linux/lowlevellock-futex.h
|
||||
(lll_futex_timed_wait_cancel): New macro.
|
||||
|
||||
2019-02-14 Wilco Dijkstra <wdijkstr@arm.com>
|
||||
|
||||
* benchtests/Makefile: Add malloc-simple benchmark.
|
||||
|
|
|
|||
|
|
@ -120,7 +120,7 @@ libpthread-routines = nptl-init nptlfreeres vars events version pt-interp \
|
|||
pt-longjmp pt-cleanup\
|
||||
cancellation \
|
||||
lowlevellock \
|
||||
lll_timedlock_wait lll_timedwait_tid \
|
||||
lll_timedlock_wait \
|
||||
pt-fork pt-vfork pt-fcntl \
|
||||
$(pthread-compat-wrappers) \
|
||||
pt-raise pt-system \
|
||||
|
|
@ -271,6 +271,7 @@ tests = tst-attr1 tst-attr2 tst-attr3 tst-default-attr \
|
|||
tst-kill1 tst-kill2 tst-kill3 tst-kill4 tst-kill5 tst-kill6 \
|
||||
tst-raise1 \
|
||||
tst-join1 tst-join2 tst-join3 tst-join4 tst-join5 tst-join6 tst-join7 \
|
||||
tst-join8 tst-join9 \
|
||||
tst-detach1 \
|
||||
tst-eintr1 tst-eintr2 tst-eintr3 tst-eintr4 tst-eintr5 \
|
||||
tst-tsd1 tst-tsd2 tst-tsd3 tst-tsd4 tst-tsd5 tst-tsd6 \
|
||||
|
|
|
|||
|
|
@ -1,70 +0,0 @@
|
|||
/* Timed waiting for thread death. Generic futex-using version.
|
||||
Copyright (C) 2003-2019 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
Contributed by Paul Mackerras <paulus@au.ibm.com>, 2003.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#include <atomic.h>
|
||||
#include <errno.h>
|
||||
#include <lowlevellock.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
afterwards. The kernel up to version 3.16.3 does not use the private futex
|
||||
operations for futex wake-up when the clone terminates. */
|
||||
int
|
||||
__lll_timedwait_tid (int *tidp, const struct timespec *abstime)
|
||||
{
|
||||
int tid;
|
||||
|
||||
if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
|
||||
return EINVAL;
|
||||
|
||||
/* Repeat until thread terminated. */
|
||||
while ((tid = *tidp) != 0)
|
||||
{
|
||||
struct timeval tv;
|
||||
struct timespec rt;
|
||||
|
||||
/* Get the current time. */
|
||||
(void) __gettimeofday (&tv, NULL);
|
||||
|
||||
/* Compute relative timeout. */
|
||||
rt.tv_sec = abstime->tv_sec - tv.tv_sec;
|
||||
rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
|
||||
if (rt.tv_nsec < 0)
|
||||
{
|
||||
rt.tv_nsec += 1000000000;
|
||||
--rt.tv_sec;
|
||||
}
|
||||
|
||||
/* Already timed out? */
|
||||
if (rt.tv_sec < 0)
|
||||
return ETIMEDOUT;
|
||||
|
||||
/* 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 (tidp, tid, &rt, LLL_SHARED) == -ETIMEDOUT)
|
||||
return ETIMEDOUT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -30,6 +30,52 @@ cleanup (void *arg)
|
|||
atomic_compare_exchange_weak_acquire (&arg, &self, NULL);
|
||||
}
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
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
|
||||
timedwait_tid (pid_t *tidp, const struct timespec *abstime)
|
||||
{
|
||||
pid_t tid;
|
||||
|
||||
if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
|
||||
return EINVAL;
|
||||
|
||||
/* Repeat until thread terminated. */
|
||||
while ((tid = *tidp) != 0)
|
||||
{
|
||||
struct timeval tv;
|
||||
struct timespec rt;
|
||||
|
||||
/* Get the current time. */
|
||||
__gettimeofday (&tv, NULL);
|
||||
|
||||
/* Compute relative timeout. */
|
||||
rt.tv_sec = abstime->tv_sec - tv.tv_sec;
|
||||
rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
|
||||
if (rt.tv_nsec < 0)
|
||||
{
|
||||
rt.tv_nsec += 1000000000;
|
||||
--rt.tv_sec;
|
||||
}
|
||||
|
||||
/* Already timed out? */
|
||||
if (rt.tv_sec < 0)
|
||||
return ETIMEDOUT;
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
__pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
|
||||
const struct timespec *abstime, bool block)
|
||||
|
|
@ -74,6 +120,10 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
|
|||
/* There is already somebody waiting for the thread. */
|
||||
return EINVAL;
|
||||
|
||||
/* BLOCK waits either indefinitely or based on an absolute time. POSIX also
|
||||
states a cancellation point shall occur for pthread_join, and we use the
|
||||
same rationale for posix_timedjoin_np. Both timedwait_tid and the futex
|
||||
call use the cancellable variant. */
|
||||
if (block)
|
||||
{
|
||||
/* During the wait we change to asynchronous cancellation. If we
|
||||
|
|
@ -81,7 +131,16 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return,
|
|||
un-wait-ed for again. */
|
||||
pthread_cleanup_push (cleanup, &pd->joinid);
|
||||
|
||||
result = lll_wait_tid (pd->tid, abstime);
|
||||
if (abstime != NULL)
|
||||
result = timedwait_tid (&pd->tid, abstime);
|
||||
else
|
||||
{
|
||||
pid_t tid;
|
||||
/* We need acquire MO here so that we synchronize with the
|
||||
kernel's store to 0 when the clone terminates. (see above) */
|
||||
while ((tid = atomic_load_acquire (&pd->tid)) != 0)
|
||||
lll_futex_wait_cancel (&pd->tid, tid, LLL_SHARED);
|
||||
}
|
||||
|
||||
pthread_cleanup_pop (0);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,6 +23,8 @@
|
|||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <support/check.h>
|
||||
#include <support/xthread.h>
|
||||
|
||||
static void
|
||||
wait_code (void)
|
||||
|
|
@ -37,22 +39,31 @@ wait_code (void)
|
|||
static pthread_barrier_t b;
|
||||
#endif
|
||||
|
||||
static int
|
||||
thread_join (pthread_t thread, void **retval)
|
||||
{
|
||||
#ifdef USE_PTHREAD_TIMEDJOIN_NP
|
||||
struct timespec tv;
|
||||
TEST_COMPARE (clock_gettime (CLOCK_REALTIME, &tv), 0);
|
||||
/* Arbitrary large timeout to make it act as pthread_join. */
|
||||
tv.tv_sec += 1000;
|
||||
return pthread_timedjoin_np ((pthread_t) thread, retval, &tv);
|
||||
#else
|
||||
return pthread_join ((pthread_t) thread, retval);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
static void *
|
||||
tf1 (void *arg)
|
||||
{
|
||||
#ifdef WAIT_IN_CHILD
|
||||
int e = pthread_barrier_wait (&b);
|
||||
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
|
||||
{
|
||||
printf ("%s: barrier_wait failed\n", __func__);
|
||||
exit (1);
|
||||
}
|
||||
xpthread_barrier_wait (&b);
|
||||
|
||||
wait_code ();
|
||||
#endif
|
||||
|
||||
pthread_join ((pthread_t) arg, NULL);
|
||||
thread_join ((pthread_t) arg, NULL);
|
||||
|
||||
exit (42);
|
||||
}
|
||||
|
|
@ -62,16 +73,12 @@ static void *
|
|||
tf2 (void *arg)
|
||||
{
|
||||
#ifdef WAIT_IN_CHILD
|
||||
int e = pthread_barrier_wait (&b);
|
||||
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
|
||||
{
|
||||
printf ("%s: barrier_wait failed\n", __func__);
|
||||
exit (1);
|
||||
}
|
||||
xpthread_barrier_wait (&b);
|
||||
|
||||
wait_code ();
|
||||
#endif
|
||||
pthread_join ((pthread_t) arg, NULL);
|
||||
|
||||
thread_join ((pthread_t) arg, NULL);
|
||||
|
||||
exit (43);
|
||||
}
|
||||
|
|
@ -81,16 +88,12 @@ static int
|
|||
do_test (void)
|
||||
{
|
||||
#ifdef WAIT_IN_CHILD
|
||||
if (pthread_barrier_init (&b, NULL, 2) != 0)
|
||||
{
|
||||
puts ("barrier_init failed");
|
||||
return 1;
|
||||
}
|
||||
xpthread_barrier_init (&b, NULL, 2);
|
||||
#endif
|
||||
|
||||
pthread_t th;
|
||||
|
||||
int err = pthread_join (pthread_self (), NULL);
|
||||
int err = thread_join (pthread_self (), NULL);
|
||||
if (err == 0)
|
||||
{
|
||||
puts ("1st circular join succeeded");
|
||||
|
|
@ -102,33 +105,20 @@ do_test (void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
if (pthread_create (&th, NULL, tf1, (void *) pthread_self ()) != 0)
|
||||
{
|
||||
puts ("1st create failed");
|
||||
return 1;
|
||||
}
|
||||
th = xpthread_create (NULL, tf1, (void *) pthread_self ());
|
||||
|
||||
#ifndef WAIT_IN_CHILD
|
||||
wait_code ();
|
||||
#endif
|
||||
|
||||
if (pthread_cancel (th) != 0)
|
||||
{
|
||||
puts ("cannot cancel 1st thread");
|
||||
return 1;
|
||||
}
|
||||
xpthread_cancel (th);
|
||||
|
||||
#ifdef WAIT_IN_CHILD
|
||||
int e = pthread_barrier_wait (&b);
|
||||
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
|
||||
{
|
||||
printf ("%s: barrier_wait failed\n", __func__);
|
||||
return 1;
|
||||
}
|
||||
xpthread_barrier_wait (&b);
|
||||
#endif
|
||||
|
||||
void *r;
|
||||
err = pthread_join (th, &r);
|
||||
err = thread_join (th, &r);
|
||||
if (err != 0)
|
||||
{
|
||||
printf ("cannot join 1st thread: %d\n", err);
|
||||
|
|
@ -140,7 +130,7 @@ do_test (void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
err = pthread_join (pthread_self (), NULL);
|
||||
err = thread_join (pthread_self (), NULL);
|
||||
if (err == 0)
|
||||
{
|
||||
puts ("2nd circular join succeeded");
|
||||
|
|
@ -152,32 +142,19 @@ do_test (void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
if (pthread_create (&th, NULL, tf2, (void *) pthread_self ()) != 0)
|
||||
{
|
||||
puts ("2nd create failed");
|
||||
return 1;
|
||||
}
|
||||
th = xpthread_create (NULL, tf2, (void *) pthread_self ());
|
||||
|
||||
#ifndef WAIT_IN_CHILD
|
||||
wait_code ();
|
||||
#endif
|
||||
|
||||
if (pthread_cancel (th) != 0)
|
||||
{
|
||||
puts ("cannot cancel 2nd thread");
|
||||
return 1;
|
||||
}
|
||||
xpthread_cancel (th);
|
||||
|
||||
#ifdef WAIT_IN_CHILD
|
||||
e = pthread_barrier_wait (&b);
|
||||
if (e != 0 && e != PTHREAD_BARRIER_SERIAL_THREAD)
|
||||
{
|
||||
printf ("%s: barrier_wait failed\n", __func__);
|
||||
return 1;
|
||||
}
|
||||
xpthread_barrier_wait (&b);
|
||||
#endif
|
||||
|
||||
if (pthread_join (th, &r) != 0)
|
||||
if (thread_join (th, &r) != 0)
|
||||
{
|
||||
puts ("cannot join 2nd thread");
|
||||
return 1;
|
||||
|
|
@ -188,7 +165,7 @@ do_test (void)
|
|||
return 1;
|
||||
}
|
||||
|
||||
err = pthread_join (pthread_self (), NULL);
|
||||
err = thread_join (pthread_self (), NULL);
|
||||
if (err == 0)
|
||||
{
|
||||
puts ("3rd circular join succeeded");
|
||||
|
|
@ -203,5 +180,4 @@ do_test (void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
#define TEST_FUNCTION do_test ()
|
||||
#include "../test-skeleton.c"
|
||||
#include <support/test-driver.c>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,20 @@
|
|||
/* Check if pthread_timedjoin_np is a cancellation entrypoint.
|
||||
Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define USE_PTHREAD_TIMEDJOIN_NP 1
|
||||
#include <nptl/tst-join5.c>
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
/* Check if pthread_timedjoin_np is a cancellation entrypoint.
|
||||
Copyright (C) 2019 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, see
|
||||
<http://www.gnu.org/licenses/>. */
|
||||
|
||||
#define USE_PTHREAD_TIMEDJOIN_NP 1
|
||||
#define WAIT_IN_CHILD 1
|
||||
#include <nptl/tst-join5.c>
|
||||
|
|
@ -82,5 +82,12 @@
|
|||
val, private) \
|
||||
-ENOSYS
|
||||
|
||||
/* Like lll_futex_wait, but acting as a cancellable entrypoint. */
|
||||
#define lll_futex_wait_cancel(futexp, val, private) \
|
||||
-ENOSYS
|
||||
|
||||
/* Like lll_futex_timed_wait, but acting as a cancellable entrypoint. */
|
||||
#define lll_futex_timed_wait_cancel(futexp, val, timeout, private) \
|
||||
-ENOSYS
|
||||
|
||||
#endif /* lowlevellock-futex.h */
|
||||
|
|
|
|||
|
|
@ -175,30 +175,4 @@ extern int __lll_timedlock_wait (int *futex, const struct timespec *,
|
|||
#define LLL_LOCK_INITIALIZER (0)
|
||||
#define LLL_LOCK_INITIALIZER_LOCKED (1)
|
||||
|
||||
extern int __lll_timedwait_tid (int *, const struct timespec *)
|
||||
attribute_hidden;
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
afterwards. The kernel up to version 3.16.3 does not use the private futex
|
||||
operations for futex wake-up when the clone terminates.
|
||||
If ABSTIME is not NULL, is used a timeout for futex call. If the timeout
|
||||
occurs then return ETIMEOUT, if ABSTIME is invalid, return EINVAL.
|
||||
The futex operation are issues with cancellable versions. */
|
||||
#define lll_wait_tid(tid, abstime) \
|
||||
({ \
|
||||
int __res = 0; \
|
||||
__typeof (tid) __tid; \
|
||||
if (abstime != NULL) \
|
||||
__res = __lll_timedwait_tid (&(tid), (abstime)); \
|
||||
else \
|
||||
/* We need acquire MO here so that we synchronize with the \
|
||||
kernel's store to 0 when the clone terminates. (see above) */ \
|
||||
while ((__tid = atomic_load_acquire (&(tid))) != 0) \
|
||||
lll_futex_wait_cancel (&(tid), __tid, LLL_SHARED); \
|
||||
__res; \
|
||||
})
|
||||
|
||||
|
||||
#endif /* lowlevellock.h */
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
/* __lll_timedwait_tid is in lowlevellock.c. */
|
||||
|
|
@ -88,44 +88,4 @@ __lll_timedlock_wait (int *futex, const struct timespec *abstime, int private)
|
|||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
__lll_timedwait_tid (int *tidp, const struct timespec *abstime)
|
||||
{
|
||||
int tid;
|
||||
|
||||
if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000)
|
||||
return EINVAL;
|
||||
|
||||
/* Repeat until thread terminated. */
|
||||
while ((tid = *tidp) != 0)
|
||||
{
|
||||
struct timeval tv;
|
||||
struct timespec rt;
|
||||
|
||||
/* Get the current time. */
|
||||
(void) __gettimeofday (&tv, NULL);
|
||||
|
||||
/* Compute relative timeout. */
|
||||
rt.tv_sec = abstime->tv_sec - tv.tv_sec;
|
||||
rt.tv_nsec = abstime->tv_nsec - tv.tv_usec * 1000;
|
||||
if (rt.tv_nsec < 0)
|
||||
{
|
||||
rt.tv_nsec += 1000000000;
|
||||
--rt.tv_sec;
|
||||
}
|
||||
|
||||
/* Already timed out? */
|
||||
if (rt.tv_sec < 0)
|
||||
return ETIMEDOUT;
|
||||
|
||||
/* Wait until thread terminates. The kernel so far does not use
|
||||
the private futex operations for this. */
|
||||
if (lll_futex_timed_wait (tidp, tid, &rt, LLL_SHARED) == -ETIMEDOUT)
|
||||
return ETIMEDOUT;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
/* __lll_timedwait_tid is in lowlevellock.S. */
|
||||
|
|
@ -365,70 +365,4 @@ __lll_unlock_wake:
|
|||
ret
|
||||
cfi_endproc
|
||||
.size __lll_unlock_wake,.-__lll_unlock_wake
|
||||
|
||||
.globl __lll_timedwait_tid
|
||||
.type __lll_timedwait_tid,@function
|
||||
.hidden __lll_timedwait_tid
|
||||
.align 16
|
||||
__lll_timedwait_tid:
|
||||
pushl %edi
|
||||
pushl %esi
|
||||
pushl %ebx
|
||||
pushl %ebp
|
||||
|
||||
movl %eax, %ebp
|
||||
movl %edx, %edi
|
||||
subl $8, %esp
|
||||
|
||||
/* Get current time. */
|
||||
2: movl %esp, %ebx
|
||||
xorl %ecx, %ecx
|
||||
movl $__NR_gettimeofday, %eax
|
||||
ENTER_KERNEL
|
||||
|
||||
/* Compute relative timeout. */
|
||||
movl 4(%esp), %eax
|
||||
movl $1000, %edx
|
||||
mul %edx /* Milli seconds to nano seconds. */
|
||||
movl (%edi), %ecx
|
||||
movl 4(%edi), %edx
|
||||
subl (%esp), %ecx
|
||||
subl %eax, %edx
|
||||
jns 5f
|
||||
addl $1000000000, %edx
|
||||
subl $1, %ecx
|
||||
5: testl %ecx, %ecx
|
||||
js 6f /* Time is already up. */
|
||||
|
||||
movl %ecx, (%esp) /* Store relative timeout. */
|
||||
movl %edx, 4(%esp)
|
||||
|
||||
movl (%ebp), %edx
|
||||
testl %edx, %edx
|
||||
jz 4f
|
||||
|
||||
movl %esp, %esi
|
||||
/* XXX The kernel so far uses global futex for the wakeup at
|
||||
all times. */
|
||||
xorl %ecx, %ecx /* movl $FUTEX_WAIT, %ecx */
|
||||
movl %ebp, %ebx
|
||||
movl $SYS_futex, %eax
|
||||
ENTER_KERNEL
|
||||
|
||||
cmpl $0, (%ebx)
|
||||
jne 1f
|
||||
4: xorl %eax, %eax
|
||||
|
||||
3: addl $8, %esp
|
||||
popl %ebp
|
||||
popl %ebx
|
||||
popl %esi
|
||||
popl %edi
|
||||
ret
|
||||
|
||||
1: cmpl $-ETIMEDOUT, %eax
|
||||
jne 2b
|
||||
6: movl $ETIMEDOUT, %eax
|
||||
jmp 3b
|
||||
.size __lll_timedwait_tid,.-__lll_timedwait_tid
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -219,31 +219,6 @@ extern int __lll_timedlock_elision (int *futex, short *adapt_count,
|
|||
#define lll_islocked(futex) \
|
||||
(futex != LLL_LOCK_INITIALIZER)
|
||||
|
||||
extern int __lll_timedwait_tid (int *tid, const struct timespec *abstime)
|
||||
__attribute__ ((regparm (2))) attribute_hidden;
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
afterwards. The kernel up to version 3.16.3 does not use the private futex
|
||||
operations for futex wake-up when the clone terminates.
|
||||
If ABSTIME is not NULL, is used a timeout for futex call. If the timeout
|
||||
occurs then return ETIMEOUT, if ABSTIME is invalid, return EINVAL.
|
||||
The futex operation are issues with cancellable versions. */
|
||||
#define lll_wait_tid(tid, abstime) \
|
||||
({ \
|
||||
int __res = 0; \
|
||||
__typeof (tid) __tid; \
|
||||
if (abstime != NULL) \
|
||||
__res = __lll_timedwait_tid (&(tid), (abstime)); \
|
||||
else \
|
||||
/* We need acquire MO here so that we synchronize with the \
|
||||
kernel's store to 0 when the clone terminates. (see above) */ \
|
||||
while ((__tid = atomic_load_acquire (&(tid))) != 0) \
|
||||
lll_futex_wait_cancel (&(tid), __tid, LLL_SHARED); \
|
||||
__res; \
|
||||
})
|
||||
|
||||
extern int __lll_lock_elision (int *futex, short *adapt_count, int private)
|
||||
attribute_hidden;
|
||||
|
||||
|
|
|
|||
|
|
@ -135,6 +135,13 @@
|
|||
__err; \
|
||||
})
|
||||
|
||||
#define lll_futex_timed_wait_cancel(futexp, val, timeout, private) \
|
||||
({ \
|
||||
int __oldtype = CANCEL_ASYNC (); \
|
||||
long int __err = lll_futex_timed_wait (futexp, val, timeout, private); \
|
||||
CANCEL_RESET (__oldtype); \
|
||||
__err; \
|
||||
})
|
||||
|
||||
#endif /* !__ASSEMBLER__ */
|
||||
|
||||
|
|
|
|||
|
|
@ -108,29 +108,4 @@ __lll_timedlock (int *futex, const struct timespec *abstime, int private)
|
|||
#define LLL_LOCK_INITIALIZER (0)
|
||||
#define LLL_LOCK_INITIALIZER_LOCKED (1)
|
||||
|
||||
extern int __lll_timedwait_tid (int *, const struct timespec *)
|
||||
attribute_hidden;
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
afterwards. The kernel up to version 3.16.3 does not use the private futex
|
||||
operations for futex wake-up when the clone terminates.
|
||||
If ABSTIME is not NULL, is used a timeout for futex call. If the timeout
|
||||
occurs then return ETIMEOUT, if ABSTIME is invalid, return EINVAL.
|
||||
The futex operation are issues with cancellable versions. */
|
||||
#define lll_wait_tid(tid, abstime) \
|
||||
({ \
|
||||
int __res = 0; \
|
||||
__typeof (tid) __tid; \
|
||||
if (abstime != NULL) \
|
||||
__res = __lll_timedwait_tid (&(tid), (abstime)); \
|
||||
else \
|
||||
/* We need acquire MO here so that we synchronize with the \
|
||||
kernel's store to 0 when the clone terminates. (see above) */ \
|
||||
while ((__tid = atomic_load_acquire (&(tid))) != 0) \
|
||||
lll_futex_wait_cancel (&(tid), __tid, LLL_SHARED); \
|
||||
__res; \
|
||||
})
|
||||
|
||||
#endif /* lowlevellock.h */
|
||||
|
|
|
|||
|
|
@ -1 +0,0 @@
|
|||
/* __lll_timedwait_tid is in lowlevellock.S. */
|
||||
|
|
@ -345,87 +345,4 @@ __lll_unlock_wake:
|
|||
retq
|
||||
cfi_endproc
|
||||
.size __lll_unlock_wake,.-__lll_unlock_wake
|
||||
|
||||
.globl __lll_timedwait_tid
|
||||
.type __lll_timedwait_tid,@function
|
||||
.hidden __lll_timedwait_tid
|
||||
.align 16
|
||||
__lll_timedwait_tid:
|
||||
cfi_startproc
|
||||
pushq %r12
|
||||
cfi_adjust_cfa_offset(8)
|
||||
pushq %r13
|
||||
cfi_adjust_cfa_offset(8)
|
||||
cfi_offset(%r12, -16)
|
||||
cfi_offset(%r13, -24)
|
||||
|
||||
movq %rdi, %r12
|
||||
movq %rsi, %r13
|
||||
|
||||
/* Align stack to 16 bytes when calling __gettimeofday. */
|
||||
subq $24, %rsp
|
||||
cfi_adjust_cfa_offset(24)
|
||||
|
||||
/* Get current time. */
|
||||
2: movq %rsp, %rdi
|
||||
xorl %esi, %esi
|
||||
/* This call works because we directly jump to a system call entry
|
||||
which preserves all the registers. */
|
||||
call JUMPTARGET(__gettimeofday)
|
||||
|
||||
/* Compute relative timeout. */
|
||||
movq 8(%rsp), %rax
|
||||
movl $1000, %edi
|
||||
mul %rdi /* Milli seconds to nano seconds. */
|
||||
movq (%r13), %rdi
|
||||
movq 8(%r13), %rsi
|
||||
subq (%rsp), %rdi
|
||||
subq %rax, %rsi
|
||||
jns 5f
|
||||
addq $1000000000, %rsi
|
||||
decq %rdi
|
||||
5: testq %rdi, %rdi
|
||||
js 6f /* Time is already up. */
|
||||
|
||||
movq %rdi, (%rsp) /* Store relative timeout. */
|
||||
movq %rsi, 8(%rsp)
|
||||
|
||||
movl (%r12), %edx
|
||||
testl %edx, %edx
|
||||
jz 4f
|
||||
|
||||
movq %rsp, %r10
|
||||
/* XXX The kernel so far uses global futex for the wakeup at
|
||||
all times. */
|
||||
#if FUTEX_WAIT == 0
|
||||
xorl %esi, %esi
|
||||
#else
|
||||
movl $FUTEX_WAIT, %esi
|
||||
#endif
|
||||
movq %r12, %rdi
|
||||
movl $SYS_futex, %eax
|
||||
syscall
|
||||
|
||||
cmpl $0, (%rdi)
|
||||
jne 1f
|
||||
4: xorl %eax, %eax
|
||||
|
||||
8: addq $24, %rsp
|
||||
cfi_adjust_cfa_offset(-24)
|
||||
popq %r13
|
||||
cfi_adjust_cfa_offset(-8)
|
||||
cfi_restore(%r13)
|
||||
popq %r12
|
||||
cfi_adjust_cfa_offset(-8)
|
||||
cfi_restore(%r12)
|
||||
retq
|
||||
|
||||
cfi_adjust_cfa_offset(32)
|
||||
1: cmpq $-ETIMEDOUT, %rax
|
||||
jne 2b
|
||||
|
||||
6: movl $ETIMEDOUT, %eax
|
||||
jmp 8b
|
||||
cfi_endproc
|
||||
.size __lll_timedwait_tid,.-__lll_timedwait_tid
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -222,31 +222,6 @@ extern int __lll_timedlock_elision (int *futex, short *adapt_count,
|
|||
#define lll_islocked(futex) \
|
||||
(futex != LLL_LOCK_INITIALIZER)
|
||||
|
||||
extern int __lll_timedwait_tid (int *, const struct timespec *)
|
||||
attribute_hidden;
|
||||
|
||||
/* The kernel notifies a process which uses CLONE_CHILD_CLEARTID via futex
|
||||
wake-up when the clone terminates. The memory location contains the
|
||||
thread ID while the clone is running and is reset to zero by the kernel
|
||||
afterwards. The kernel up to version 3.16.3 does not use the private futex
|
||||
operations for futex wake-up when the clone terminates.
|
||||
If ABSTIME is not NULL, is used a timeout for futex call. If the timeout
|
||||
occurs then return ETIMEOUT, if ABSTIME is invalid, return EINVAL.
|
||||
The futex operation are issues with cancellable versions. */
|
||||
#define lll_wait_tid(tid, abstime) \
|
||||
({ \
|
||||
int __res = 0; \
|
||||
__typeof (tid) __tid; \
|
||||
if (abstime != NULL) \
|
||||
__res = __lll_timedwait_tid (&(tid), (abstime)); \
|
||||
else \
|
||||
/* We need acquire MO here so that we synchronize with the \
|
||||
kernel's store to 0 when the clone terminates. (see above) */ \
|
||||
while ((__tid = atomic_load_acquire (&(tid))) != 0) \
|
||||
lll_futex_wait_cancel (&(tid), __tid, LLL_SHARED); \
|
||||
__res; \
|
||||
})
|
||||
|
||||
extern int __lll_lock_elision (int *futex, short *adapt_count, int private)
|
||||
attribute_hidden;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue