From 69ca4b54c151cec42ccca5e05790efc1a8206b47 Mon Sep 17 00:00:00 2001 From: Mike Crowe Date: Thu, 31 Oct 2019 10:03:21 -0300 Subject: nptl: Add pthread_clockjoin_np Introduce pthread_clockjoin_np as a version of pthread_timedjoin_np that accepts a clockid_t parameter to indicate which clock the timeout should be measured against. This mirrors the recently-added POSIX-proposed "clock" wait functions. Checked on x86_64-linux-gnu. Reviewed-by: Adhemerval Zanella --- nptl/Makefile | 5 +++-- nptl/Versions | 4 ++++ nptl/pthreadP.h | 7 ++++--- nptl/pthread_clockjoin.c | 29 +++++++++++++++++++++++++++++ nptl/pthread_join.c | 3 ++- nptl/pthread_join_common.c | 16 +++++++++------- nptl/pthread_timedjoin.c | 3 ++- nptl/pthread_tryjoin.c | 3 ++- nptl/thrd_join.c | 2 +- nptl/tst-join10.c | 20 ++++++++++++++++++++ nptl/tst-join11.c | 21 +++++++++++++++++++++ nptl/tst-join12.c | 20 ++++++++++++++++++++ nptl/tst-join13.c | 21 +++++++++++++++++++++ nptl/tst-join3.c | 33 ++++++++++++++++++++++++++++----- nptl/tst-join5.c | 22 +++++++++++++++------- 15 files changed, 181 insertions(+), 28 deletions(-) create mode 100644 nptl/pthread_clockjoin.c create mode 100644 nptl/tst-join10.c create mode 100644 nptl/tst-join11.c create mode 100644 nptl/tst-join12.c create mode 100644 nptl/tst-join13.c (limited to 'nptl') diff --git a/nptl/Makefile b/nptl/Makefile index 41f8f5e..bbb281e 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -53,7 +53,7 @@ pthread-compat-wrappers = \ libpthread-routines = nptl-init nptlfreeres vars events version pt-interp \ pthread_create pthread_exit pthread_detach \ pthread_join pthread_tryjoin pthread_timedjoin \ - pthread_join_common pthread_yield \ + pthread_clockjoin pthread_join_common pthread_yield \ pthread_getconcurrency pthread_setconcurrency \ pthread_getschedparam pthread_setschedparam \ pthread_setschedprio \ @@ -189,6 +189,7 @@ CFLAGS-forward.c += -fexceptions CFLAGS-pthread_testcancel.c += -fexceptions CFLAGS-pthread_join.c += -fexceptions -fasynchronous-unwind-tables CFLAGS-pthread_timedjoin.c += -fexceptions -fasynchronous-unwind-tables +CFLAGS-pthread_clockjoin.c += -fexceptions -fasynchronous-unwind-tables CFLAGS-pthread_once.c += $(uses-callbacks) -fexceptions \ -fasynchronous-unwind-tables CFLAGS-pthread_cond_wait.c += -fexceptions -fasynchronous-unwind-tables @@ -273,7 +274,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-join8 tst-join9 tst-join10 tst-join11 tst-join12 tst-join13 \ tst-detach1 \ tst-eintr2 tst-eintr3 tst-eintr4 tst-eintr5 \ tst-tsd1 tst-tsd2 tst-tsd3 tst-tsd4 tst-tsd5 tst-tsd6 \ diff --git a/nptl/Versions b/nptl/Versions index be7e810..adbd4fa 100644 --- a/nptl/Versions +++ b/nptl/Versions @@ -277,6 +277,10 @@ libpthread { pthread_mutex_clocklock; } + GLIBC_2.31 { + pthread_clockjoin_np; + } + GLIBC_PRIVATE { __pthread_initialize_minimal; __pthread_clock_gettime; __pthread_clock_settime; diff --git a/nptl/pthreadP.h b/nptl/pthreadP.h index 070b3af..bbb2bf0 100644 --- a/nptl/pthreadP.h +++ b/nptl/pthreadP.h @@ -475,8 +475,10 @@ extern int __pthread_setcanceltype (int type, int *oldtype); 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_timedjoin_ex (pthread_t, void **, const struct timespec *, - bool); +extern int __pthread_clockjoin_ex (pthread_t, void **, clockid_t, + const struct timespec *, bool) + attribute_hidden; + #if IS_IN (libpthread) hidden_proto (__pthread_mutex_init) @@ -495,7 +497,6 @@ hidden_proto (__pthread_setcancelstate) hidden_proto (__pthread_testcancel) hidden_proto (__pthread_mutexattr_init) hidden_proto (__pthread_mutexattr_settype) -hidden_proto (__pthread_timedjoin_ex) #endif extern int __pthread_cond_broadcast_2_0 (pthread_cond_2_0_t *cond); diff --git a/nptl/pthread_clockjoin.c b/nptl/pthread_clockjoin.c new file mode 100644 index 0000000..7c8c3ac --- /dev/null +++ b/nptl/pthread_clockjoin.c @@ -0,0 +1,29 @@ +/* Join with a terminated thread using an specific clock. + 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 + . */ + +#include "pthreadP.h" + +int +__pthread_clockjoin_np (pthread_t threadid, void **thread_return, + clockid_t clockid, + const struct timespec *abstime) +{ + return __pthread_clockjoin_ex (threadid, thread_return, + clockid, abstime, true); +} +weak_alias (__pthread_clockjoin_np, pthread_clockjoin_np) diff --git a/nptl/pthread_join.c b/nptl/pthread_join.c index 3523b20..c7ff5a3 100644 --- a/nptl/pthread_join.c +++ b/nptl/pthread_join.c @@ -21,6 +21,7 @@ int __pthread_join (pthread_t threadid, void **thread_return) { - return __pthread_timedjoin_ex (threadid, thread_return, NULL, true); + return __pthread_clockjoin_ex (threadid, thread_return, 0 /* Ignored */, + NULL, true); } weak_alias (__pthread_join, pthread_join) diff --git a/nptl/pthread_join_common.c b/nptl/pthread_join_common.c index 4d91c6f..998d227 100644 --- a/nptl/pthread_join_common.c +++ b/nptl/pthread_join_common.c @@ -37,7 +37,7 @@ 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 -timedwait_tid (pid_t *tidp, const struct timespec *abstime) +clockwait_tid (pid_t *tidp, clockid_t clockid, const struct timespec *abstime) { pid_t tid; @@ -49,8 +49,10 @@ timedwait_tid (pid_t *tidp, const struct timespec *abstime) { struct timespec rt; - /* Get the current time. */ - __clock_gettime (CLOCK_REALTIME, &rt); + /* Get the current time. This can only fail if clockid is + invalid. */ + if (__glibc_unlikely (__clock_gettime (clockid, &rt))) + return EINVAL; /* Compute relative timeout. */ rt.tv_sec = abstime->tv_sec - rt.tv_sec; @@ -77,7 +79,8 @@ timedwait_tid (pid_t *tidp, const struct timespec *abstime) } int -__pthread_timedjoin_ex (pthread_t threadid, void **thread_return, +__pthread_clockjoin_ex (pthread_t threadid, void **thread_return, + clockid_t clockid, const struct timespec *abstime, bool block) { struct pthread *pd = (struct pthread *) threadid; @@ -122,7 +125,7 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return, /* 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 + same rationale for posix_timedjoin_np. Both clockwait_tid and the futex call use the cancellable variant. */ if (block) { @@ -132,7 +135,7 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return, pthread_cleanup_push (cleanup, &pd->joinid); if (abstime != NULL) - result = timedwait_tid (&pd->tid, abstime); + result = clockwait_tid (&pd->tid, clockid, abstime); else { pid_t tid; @@ -165,4 +168,3 @@ __pthread_timedjoin_ex (pthread_t threadid, void **thread_return, return result; } -hidden_def (__pthread_timedjoin_ex) diff --git a/nptl/pthread_timedjoin.c b/nptl/pthread_timedjoin.c index bb48a1e..1890d1a 100644 --- a/nptl/pthread_timedjoin.c +++ b/nptl/pthread_timedjoin.c @@ -22,6 +22,7 @@ int __pthread_timedjoin_np (pthread_t threadid, void **thread_return, const struct timespec *abstime) { - return __pthread_timedjoin_ex (threadid, thread_return, abstime, true); + return __pthread_clockjoin_ex (threadid, thread_return, + CLOCK_REALTIME, abstime, true); } weak_alias (__pthread_timedjoin_np, pthread_timedjoin_np) diff --git a/nptl/pthread_tryjoin.c b/nptl/pthread_tryjoin.c index 28e765b..a15fd5f 100644 --- a/nptl/pthread_tryjoin.c +++ b/nptl/pthread_tryjoin.c @@ -28,5 +28,6 @@ pthread_tryjoin_np (pthread_t threadid, void **thread_return) /* If pd->tid == 0 then lll_wait_tid will not block on futex operation. */ - return __pthread_timedjoin_ex (threadid, thread_return, NULL, false); + return __pthread_clockjoin_ex (threadid, thread_return, 0 /* Ignored */, + NULL, false); } diff --git a/nptl/thrd_join.c b/nptl/thrd_join.c index 497d0d2..10d9a72 100644 --- a/nptl/thrd_join.c +++ b/nptl/thrd_join.c @@ -22,7 +22,7 @@ int thrd_join (thrd_t thr, int *res) { void *pthread_res; - int err_code = __pthread_timedjoin_ex (thr, &pthread_res, NULL, true); + int err_code = __pthread_clockjoin_ex (thr, &pthread_res, 0, NULL, true); if (res) *res = (int) (uintptr_t) pthread_res; diff --git a/nptl/tst-join10.c b/nptl/tst-join10.c new file mode 100644 index 0000000..a222dd1 --- /dev/null +++ b/nptl/tst-join10.c @@ -0,0 +1,20 @@ +/* Check if pthread_clockjoin_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 + . */ + +#define USE_PTHREAD_CLOCKJOIN_NP_REALTIME 1 +#include diff --git a/nptl/tst-join11.c b/nptl/tst-join11.c new file mode 100644 index 0000000..341588a --- /dev/null +++ b/nptl/tst-join11.c @@ -0,0 +1,21 @@ +/* Check if pthread_clockjoin_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 + . */ + +#define USE_PTHREAD_CLOCKJOIN_NP_REALTIME 1 +#define WAIT_IN_CHILD 1 +#include diff --git a/nptl/tst-join12.c b/nptl/tst-join12.c new file mode 100644 index 0000000..44592dc --- /dev/null +++ b/nptl/tst-join12.c @@ -0,0 +1,20 @@ +/* Check if pthread_clockjoin_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 + . */ + +#define USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC 1 +#include diff --git a/nptl/tst-join13.c b/nptl/tst-join13.c new file mode 100644 index 0000000..d4e49d5 --- /dev/null +++ b/nptl/tst-join13.c @@ -0,0 +1,21 @@ +/* Check if pthread_clockjoin_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 + . */ + +#define USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC 1 +#define WAIT_IN_CHILD 1 +#include diff --git a/nptl/tst-join3.c b/nptl/tst-join3.c index a4ae459..faf7683 100644 --- a/nptl/tst-join3.c +++ b/nptl/tst-join3.c @@ -28,6 +28,8 @@ #include +#define CLOCK_USE_TIMEDJOIN (-1) + static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; @@ -35,32 +37,44 @@ static void * tf (void *arg) { xpthread_mutex_lock (&lock); + xpthread_mutex_unlock (&lock); return (void *) 42l; } static int -do_test (void) +do_test_clock (clockid_t clockid) { + const clockid_t clockid_for_get = + (clockid == CLOCK_USE_TIMEDJOIN) ? CLOCK_REALTIME : clockid; + xpthread_mutex_lock (&lock); pthread_t th = xpthread_create (NULL, tf, NULL); void *status; - struct timespec timeout = timespec_add (xclock_now (CLOCK_REALTIME), + struct timespec timeout = timespec_add (xclock_now (clockid_for_get), make_timespec (0, 200000000)); - int val = pthread_timedjoin_np (th, &status, &timeout); + int val; + if (clockid == CLOCK_USE_TIMEDJOIN) + val = pthread_timedjoin_np (th, &status, &timeout); + else + val = pthread_clockjoin_np (th, &status, clockid, &timeout); + TEST_COMPARE (val, ETIMEDOUT); xpthread_mutex_unlock (&lock); while (1) { - timeout = timespec_add (xclock_now (CLOCK_REALTIME), + timeout = timespec_add (xclock_now (clockid_for_get), make_timespec (0, 200000000)); - val = pthread_timedjoin_np (th, &status, &timeout); + if (clockid == CLOCK_USE_TIMEDJOIN) + val = pthread_timedjoin_np (th, &status, &timeout); + else + val = pthread_clockjoin_np (th, &status, clockid, &timeout); if (val == 0) break; @@ -73,4 +87,13 @@ do_test (void) return 0; } +static int +do_test (void) +{ + do_test_clock (CLOCK_USE_TIMEDJOIN); + do_test_clock (CLOCK_REALTIME); + do_test_clock (CLOCK_MONOTONIC); + return 0; +} + #include diff --git a/nptl/tst-join5.c b/nptl/tst-join5.c index 41cacf1..2fa178c 100644 --- a/nptl/tst-join5.c +++ b/nptl/tst-join5.c @@ -24,7 +24,9 @@ #include #include +#include #include +#include static void wait_code (void) @@ -42,14 +44,20 @@ static pthread_barrier_t b; 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); +#if defined USE_PTHREAD_TIMEDJOIN_NP + const struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME), + make_timespec (1000, 0)); + return pthread_timedjoin_np (thread, retval, &ts); +#elif defined USE_PTHREAD_CLOCKJOIN_NP_REALTIME + const struct timespec ts = timespec_add (xclock_now (CLOCK_REALTIME), + make_timespec (1000, 0)); + return pthread_clockjoin_np (thread, retval, CLOCK_REALTIME, &ts); +#elif defined USE_PTHREAD_CLOCKJOIN_NP_MONOTONIC + const struct timespec ts = timespec_add (xclock_now (CLOCK_MONOTONIC), + make_timespec (1000, 0)); + return pthread_clockjoin_np (thread, retval, CLOCK_MONOTONIC, &ts); #else - return pthread_join ((pthread_t) thread, retval); + return pthread_join (thread, retval); #endif } -- cgit v1.1