diff options
Diffstat (limited to 'nptl')
| -rw-r--r-- | nptl/allocatestack.c | 2 | ||||
| -rw-r--r-- | nptl/cancellation.c | 50 | ||||
| -rw-r--r-- | nptl/cleanup_defer.c | 42 | ||||
| -rw-r--r-- | nptl/descr.h | 41 | ||||
| -rw-r--r-- | nptl/libc-cleanup.c | 39 | ||||
| -rw-r--r-- | nptl/pthread_cancel.c | 110 | ||||
| -rw-r--r-- | nptl/pthread_join_common.c | 7 | ||||
| -rw-r--r-- | nptl/pthread_setcancelstate.c | 26 | ||||
| -rw-r--r-- | nptl/pthread_setcanceltype.c | 31 | ||||
| -rw-r--r-- | nptl/pthread_testcancel.c | 9 |
10 files changed, 272 insertions, 85 deletions
diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 34a33164ff..01a282f3f6 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -119,8 +119,6 @@ get_cached_stack (size_t *sizep, void **memp) /* Cancellation handling is back to the default. */ result->cancelhandling = 0; - result->cancelstate = PTHREAD_CANCEL_ENABLE; - result->canceltype = PTHREAD_CANCEL_DEFERRED; result->cleanup = NULL; result->setup_failed = 0; diff --git a/nptl/cancellation.c b/nptl/cancellation.c index 8d54a6add1..f4b08902b2 100644 --- a/nptl/cancellation.c +++ b/nptl/cancellation.c @@ -30,19 +30,26 @@ int __pthread_enable_asynccancel (void) { struct pthread *self = THREAD_SELF; + int oldval = atomic_load_relaxed (&self->cancelhandling); - int oldval = THREAD_GETMEM (self, canceltype); - THREAD_SETMEM (self, canceltype, PTHREAD_CANCEL_ASYNCHRONOUS); + while (1) + { + int newval = oldval | CANCELTYPE_BITMASK; - int ch = THREAD_GETMEM (self, cancelhandling); + if (newval == oldval) + break; - if (self->cancelstate == PTHREAD_CANCEL_ENABLE - && (ch & CANCELED_BITMASK) - && !(ch & EXITING_BITMASK) - && !(ch & TERMINATED_BITMASK)) - { - THREAD_SETMEM (self, result, PTHREAD_CANCELED); - __do_cancel (); + if (atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &oldval, newval)) + { + if (cancel_enabled_and_canceled_and_async (newval)) + { + self->result = PTHREAD_CANCELED; + __do_cancel (); + } + + break; + } } return oldval; @@ -56,10 +63,29 @@ __pthread_disable_asynccancel (int oldtype) { /* If asynchronous cancellation was enabled before we do not have anything to do. */ - if (oldtype == PTHREAD_CANCEL_ASYNCHRONOUS) + if (oldtype & CANCELTYPE_BITMASK) return; struct pthread *self = THREAD_SELF; - self->canceltype = PTHREAD_CANCEL_DEFERRED; + int newval; + int oldval = atomic_load_relaxed (&self->cancelhandling); + do + { + newval = oldval & ~CANCELTYPE_BITMASK; + } + while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &oldval, newval)); + + /* We cannot return when we are being canceled. Upon return the + thread might be things which would have to be undone. The + following loop should loop until the cancellation signal is + delivered. */ + while (__glibc_unlikely ((newval & (CANCELING_BITMASK | CANCELED_BITMASK)) + == CANCELING_BITMASK)) + { + futex_wait_simple ((unsigned int *) &self->cancelhandling, newval, + FUTEX_PRIVATE); + newval = atomic_load_relaxed (&self->cancelhandling); + } } libc_hidden_def (__pthread_disable_asynccancel) diff --git a/nptl/cleanup_defer.c b/nptl/cleanup_defer.c index f8181a40e8..eb0bc77740 100644 --- a/nptl/cleanup_defer.c +++ b/nptl/cleanup_defer.c @@ -30,9 +30,22 @@ ___pthread_register_cancel_defer (__pthread_unwind_buf_t *buf) ibuf->priv.data.prev = THREAD_GETMEM (self, cleanup_jmp_buf); ibuf->priv.data.cleanup = THREAD_GETMEM (self, cleanup); - /* Disable asynchronous cancellation for now. */ - ibuf->priv.data.canceltype = THREAD_GETMEM (self, canceltype); - THREAD_SETMEM (self, canceltype, PTHREAD_CANCEL_DEFERRED); + int cancelhandling = atomic_load_relaxed (&self->cancelhandling); + if (__glibc_unlikely (cancelhandling & CANCELTYPE_BITMASK)) + { + int newval; + do + { + newval = cancelhandling & ~CANCELTYPE_BITMASK; + } + while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &cancelhandling, + newval)); + } + + ibuf->priv.data.canceltype = (cancelhandling & CANCELTYPE_BITMASK + ? PTHREAD_CANCEL_ASYNCHRONOUS + : PTHREAD_CANCEL_DEFERRED); /* Store the new cleanup handler info. */ THREAD_SETMEM (self, cleanup_jmp_buf, (struct pthread_unwind_buf *) buf); @@ -54,9 +67,26 @@ ___pthread_unregister_cancel_restore (__pthread_unwind_buf_t *buf) THREAD_SETMEM (self, cleanup_jmp_buf, ibuf->priv.data.prev); - THREAD_SETMEM (self, canceltype, ibuf->priv.data.canceltype); - if (ibuf->priv.data.canceltype == PTHREAD_CANCEL_ASYNCHRONOUS) - __pthread_testcancel (); + if (ibuf->priv.data.canceltype == PTHREAD_CANCEL_DEFERRED) + return; + + int cancelhandling = atomic_load_relaxed (&self->cancelhandling); + if (cancelhandling & CANCELTYPE_BITMASK) + { + int newval; + do + { + newval = cancelhandling | CANCELTYPE_BITMASK; + } + while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &cancelhandling, newval)); + + if (cancel_enabled_and_canceled (cancelhandling)) + { + self->result = PTHREAD_CANCELED; + __do_cancel (); + } + } } versioned_symbol (libc, ___pthread_unregister_cancel_restore, __pthread_unregister_cancel_restore, GLIBC_2_34); diff --git a/nptl/descr.h b/nptl/descr.h index ea8aca08e6..bb46b5958e 100644 --- a/nptl/descr.h +++ b/nptl/descr.h @@ -279,18 +279,27 @@ struct pthread /* Flags determining processing of cancellation. */ int cancelhandling; + /* Bit set if cancellation is disabled. */ +#define CANCELSTATE_BIT 0 +#define CANCELSTATE_BITMASK (1 << CANCELSTATE_BIT) + /* Bit set if asynchronous cancellation mode is selected. */ +#define CANCELTYPE_BIT 1 +#define CANCELTYPE_BITMASK (1 << CANCELTYPE_BIT) + /* Bit set if canceling has been initiated. */ +#define CANCELING_BIT 2 +#define CANCELING_BITMASK (1 << CANCELING_BIT) /* Bit set if canceled. */ #define CANCELED_BIT 3 -#define CANCELED_BITMASK (0x01 << CANCELED_BIT) +#define CANCELED_BITMASK (1 << CANCELED_BIT) /* Bit set if thread is exiting. */ #define EXITING_BIT 4 -#define EXITING_BITMASK (0x01 << EXITING_BIT) +#define EXITING_BITMASK (1 << EXITING_BIT) /* Bit set if thread terminated and TCB is freed. */ #define TERMINATED_BIT 5 -#define TERMINATED_BITMASK (0x01 << TERMINATED_BIT) +#define TERMINATED_BITMASK (1 << TERMINATED_BIT) /* Bit set if thread is supposed to change XID. */ #define SETXID_BIT 6 -#define SETXID_BITMASK (0x01 << SETXID_BIT) +#define SETXID_BITMASK (1 << SETXID_BIT) /* Flags. Including those copied from the thread attribute. */ int flags; @@ -390,14 +399,6 @@ struct pthread /* Indicates whether is a C11 thread created by thrd_creat. */ bool c11; - /* Thread cancel state (PTHREAD_CANCEL_ENABLE or - PTHREAD_CANCEL_DISABLE). */ - unsigned char cancelstate; - - /* Thread cancel type (PTHREAD_CANCEL_DEFERRED or - PTHREAD_CANCEL_ASYNCHRONOUS). */ - unsigned char canceltype; - /* Used in __pthread_kill_internal to detected a thread that has exited or is about to exit. exit_lock must only be acquired after blocking signals. */ @@ -417,6 +418,22 @@ struct pthread (sizeof (struct pthread) - offsetof (struct pthread, end_padding)) } __attribute ((aligned (TCB_ALIGNMENT))); +static inline bool +cancel_enabled_and_canceled (int value) +{ + return (value & (CANCELSTATE_BITMASK | CANCELED_BITMASK | EXITING_BITMASK + | TERMINATED_BITMASK)) + == CANCELED_BITMASK; +} + +static inline bool +cancel_enabled_and_canceled_and_async (int value) +{ + return ((value) & (CANCELSTATE_BITMASK | CANCELTYPE_BITMASK | CANCELED_BITMASK + | EXITING_BITMASK | TERMINATED_BITMASK)) + == (CANCELTYPE_BITMASK | CANCELED_BITMASK); +} + /* This yields the pointer that TLS support code calls the thread pointer. */ #if TLS_TCB_AT_TP # define TLS_TPADJ(pd) (pd) diff --git a/nptl/libc-cleanup.c b/nptl/libc-cleanup.c index cb4c226281..c4a83591bf 100644 --- a/nptl/libc-cleanup.c +++ b/nptl/libc-cleanup.c @@ -26,9 +26,24 @@ __libc_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer) buffer->__prev = THREAD_GETMEM (self, cleanup); + int cancelhandling = atomic_load_relaxed (&self->cancelhandling); + /* Disable asynchronous cancellation for now. */ - buffer->__canceltype = THREAD_GETMEM (self, canceltype); - THREAD_SETMEM (self, canceltype, PTHREAD_CANCEL_DEFERRED); + if (__glibc_unlikely (cancelhandling & CANCELTYPE_BITMASK)) + { + int newval; + do + { + newval = cancelhandling & ~CANCELTYPE_BITMASK; + } + while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &cancelhandling, + newval)); + } + + buffer->__canceltype = (cancelhandling & CANCELTYPE_BITMASK + ? PTHREAD_CANCEL_ASYNCHRONOUS + : PTHREAD_CANCEL_DEFERRED); THREAD_SETMEM (self, cleanup, buffer); } @@ -41,8 +56,22 @@ __libc_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer) THREAD_SETMEM (self, cleanup, buffer->__prev); - THREAD_SETMEM (self, canceltype, buffer->__canceltype); - if (buffer->__canceltype == PTHREAD_CANCEL_ASYNCHRONOUS) - __pthread_testcancel (); + int cancelhandling = atomic_load_relaxed (&self->cancelhandling); + if (cancelhandling & CANCELTYPE_BITMASK) + { + int newval; + do + { + newval = cancelhandling | CANCELTYPE_BITMASK; + } + while (!atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &cancelhandling, newval)); + + if (cancel_enabled_and_canceled (cancelhandling)) + { + self->result = PTHREAD_CANCELED; + __do_cancel (); + } + } } libc_hidden_def (__libc_cleanup_pop_restore) diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c index 7524c7ce4d..c76882e279 100644 --- a/nptl/pthread_cancel.c +++ b/nptl/pthread_cancel.c @@ -42,18 +42,29 @@ sigcancel_handler (int sig, siginfo_t *si, void *ctx) struct pthread *self = THREAD_SELF; - int ch = atomic_load_relaxed (&self->cancelhandling); - /* Cancelation not enabled, not cancelled, or already exitting. */ - if (self->cancelstate == PTHREAD_CANCEL_DISABLE - || (ch & CANCELED_BITMASK) == 0 - || (ch & EXITING_BITMASK) != 0) - return; - - /* Set the return value. */ - THREAD_SETMEM (self, result, PTHREAD_CANCELED); - /* Make sure asynchronous cancellation is still enabled. */ - if (self->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS) - __do_cancel (); + int oldval = atomic_load_relaxed (&self->cancelhandling); + while (1) + { + /* We are canceled now. When canceled by another thread this flag + is already set but if the signal is directly send (internally or + from another process) is has to be done here. */ + int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK; + + if (oldval == newval || (oldval & EXITING_BITMASK) != 0) + /* Already canceled or exiting. */ + break; + + if (atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &oldval, newval)) + { + self->result = PTHREAD_CANCELED; + + /* Make sure asynchronous cancellation is still enabled. */ + if ((oldval & CANCELTYPE_BITMASK) != 0) + /* Run the registered destructors and terminate the thread. */ + __do_cancel (); + } + } } int @@ -92,29 +103,70 @@ __pthread_cancel (pthread_t th) } #endif - int oldch = atomic_fetch_or_acquire (&pd->cancelhandling, CANCELED_BITMASK); - if ((oldch & CANCELED_BITMASK) != 0) - return 0; - - if (pd == THREAD_SELF) + /* Some syscalls are never restarted after being interrupted by a signal + handler, regardless of the use of SA_RESTART (they always fail with + EINTR). So pthread_cancel cannot send SIGCANCEL unless the cancellation + is enabled and set as asynchronous (in this case the cancellation will + be acted in the cancellation handler instead by the syscall wrapper). + Otherwise the target thread is set as 'cancelling' (CANCELING_BITMASK) + by atomically setting 'cancelhandling' and the cancelation will be acted + upon on next cancellation entrypoing in the target thread. + + It also requires to atomically check if cancellation is enabled and + asynchronous, so both cancellation state and type are tracked on + 'cancelhandling'. */ + + int result = 0; + int oldval = atomic_load_relaxed (&pd->cancelhandling); + int newval; + do { - /* A single-threaded process should be able to kill itself, since there - is nothing in the POSIX specification that says that it cannot. So - we set multiple_threads to true so that cancellation points get - executed. */ - THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1); + newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK; + if (oldval == newval) + break; + + /* If the cancellation is handled asynchronously just send a + signal. We avoid this if possible since it's more + expensive. */ + if (cancel_enabled_and_canceled_and_async (newval)) + { + /* Mark the cancellation as "in progress". */ + int newval2 = oldval | CANCELING_BITMASK; + if (!atomic_compare_exchange_weak_acquire (&pd->cancelhandling, + &oldval, newval2)) + continue; + + if (pd == THREAD_SELF) + /* This is not merely an optimization: An application may + call pthread_cancel (pthread_self ()) without calling + pthread_create, so the signal handler may not have been + set up for a self-cancel. */ + { + pd->result = PTHREAD_CANCELED; + if ((newval & CANCELTYPE_BITMASK) != 0) + __do_cancel (); + } + else + /* The cancellation handler will take care of marking the + thread as canceled. */ + result = __pthread_kill_internal (th, SIGCANCEL); + + break; + } + + /* A single-threaded process should be able to kill itself, since + there is nothing in the POSIX specification that says that it + cannot. So we set multiple_threads to true so that cancellation + points get executed. */ + THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1); #ifndef TLS_MULTIPLE_THREADS_IN_TCB __libc_multiple_threads = 1; #endif - - THREAD_SETMEM (pd, result, PTHREAD_CANCELED); - if (pd->cancelstate == PTHREAD_CANCEL_ENABLE - && pd->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS) - __do_cancel (); - return 0; } + while (!atomic_compare_exchange_weak_acquire (&pd->cancelhandling, &oldval, + newval)); - return __pthread_kill_internal (th, SIGCANCEL); + return result; } versioned_symbol (libc, __pthread_cancel, pthread_cancel, GLIBC_2_34); diff --git a/nptl/pthread_join_common.c b/nptl/pthread_join_common.c index a8e884f341..ca3245b0af 100644 --- a/nptl/pthread_join_common.c +++ b/nptl/pthread_join_common.c @@ -57,12 +57,9 @@ __pthread_clockjoin_ex (pthread_t threadid, void **thread_return, if ((pd == self || (self->joinid == pd && (pd->cancelhandling - & (CANCELED_BITMASK | EXITING_BITMASK + & (CANCELING_BITMASK | CANCELED_BITMASK | EXITING_BITMASK | TERMINATED_BITMASK)) == 0)) - && !(self->cancelstate == PTHREAD_CANCEL_ENABLE - && (pd->cancelhandling & (CANCELED_BITMASK | EXITING_BITMASK - | TERMINATED_BITMASK)) - == CANCELED_BITMASK)) + && !cancel_enabled_and_canceled (self->cancelhandling)) /* This is a deadlock situation. The threads are waiting for each other to finish. Note that this is a "may" error. To be 100% sure we catch this error we would have to lock the data diff --git a/nptl/pthread_setcancelstate.c b/nptl/pthread_setcancelstate.c index 9905b12e4f..f8edf18fbe 100644 --- a/nptl/pthread_setcancelstate.c +++ b/nptl/pthread_setcancelstate.c @@ -30,9 +30,29 @@ __pthread_setcancelstate (int state, int *oldstate) self = THREAD_SELF; - if (oldstate != NULL) - *oldstate = self->cancelstate; - self->cancelstate = state; + int oldval = atomic_load_relaxed (&self->cancelhandling); + while (1) + { + int newval = (state == PTHREAD_CANCEL_DISABLE + ? oldval | CANCELSTATE_BITMASK + : oldval & ~CANCELSTATE_BITMASK); + + if (oldstate != NULL) + *oldstate = ((oldval & CANCELSTATE_BITMASK) + ? PTHREAD_CANCEL_DISABLE : PTHREAD_CANCEL_ENABLE); + + if (oldval == newval) + break; + + if (atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &oldval, newval)) + { + if (cancel_enabled_and_canceled_and_async (newval)) + __do_cancel (); + + break; + } + } return 0; } diff --git a/nptl/pthread_setcanceltype.c b/nptl/pthread_setcanceltype.c index 94e56466de..1307d355c1 100644 --- a/nptl/pthread_setcanceltype.c +++ b/nptl/pthread_setcanceltype.c @@ -28,11 +28,32 @@ __pthread_setcanceltype (int type, int *oldtype) volatile struct pthread *self = THREAD_SELF; - if (oldtype != NULL) - *oldtype = self->canceltype; - self->canceltype = type; - if (type == PTHREAD_CANCEL_ASYNCHRONOUS) - __pthread_testcancel (); + int oldval = atomic_load_relaxed (&self->cancelhandling); + while (1) + { + int newval = (type == PTHREAD_CANCEL_ASYNCHRONOUS + ? oldval | CANCELTYPE_BITMASK + : oldval & ~CANCELTYPE_BITMASK); + + if (oldtype != NULL) + *oldtype = ((oldval & CANCELTYPE_BITMASK) + ? PTHREAD_CANCEL_ASYNCHRONOUS : PTHREAD_CANCEL_DEFERRED); + + if (oldval == newval) + break; + + if (atomic_compare_exchange_weak_acquire (&self->cancelhandling, + &oldval, newval)) + { + if (cancel_enabled_and_canceled_and_async (newval)) + { + THREAD_SETMEM (self, result, PTHREAD_CANCELED); + __do_cancel (); + } + + break; + } + } return 0; } diff --git a/nptl/pthread_testcancel.c b/nptl/pthread_testcancel.c index 13123608e8..b81928c000 100644 --- a/nptl/pthread_testcancel.c +++ b/nptl/pthread_testcancel.c @@ -23,13 +23,10 @@ void ___pthread_testcancel (void) { struct pthread *self = THREAD_SELF; - int cancelhandling = THREAD_GETMEM (self, cancelhandling); - if (self->cancelstate == PTHREAD_CANCEL_ENABLE - && (cancelhandling & CANCELED_BITMASK) - && !(cancelhandling & EXITING_BITMASK) - && !(cancelhandling & TERMINATED_BITMASK)) + int cancelhandling = atomic_load_relaxed (&self->cancelhandling); + if (cancel_enabled_and_canceled (cancelhandling)) { - THREAD_SETMEM (self, result, PTHREAD_CANCELED); + self->result = PTHREAD_CANCELED; __do_cancel (); } } |