From patchwork Thu Sep 30 20:00:41 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adhemerval Zanella Netto X-Patchwork-Id: 45628 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 8D6D83857C6C for ; Thu, 30 Sep 2021 20:05:37 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 8D6D83857C6C DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1633032337; bh=LWU3lFvKccyPrK+7SyNa/ZrfC78y7k5JZIU1I52Nquo=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=c/8+VUE25HEUrKpTjMFN4B1lTIJH2WYDOUk3WnVMzPSTMQXqFaQZiGYxKKQEuxERH D5HVhyyURrg2mFhaffNDlx+g87qH1qNV3HHWO3rnI/Qy8MsIuXhj9HtiDq6x1mGhvX UYWn42TevI5WNzD3nWxFgbTEp8vkqs0cJW8YpaJw= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-qt1-x832.google.com (mail-qt1-x832.google.com [IPv6:2607:f8b0:4864:20::832]) by sourceware.org (Postfix) with ESMTPS id D1FC3385842F for ; Thu, 30 Sep 2021 20:01:02 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org D1FC3385842F Received: by mail-qt1-x832.google.com with SMTP id f15so6882765qtv.9 for ; Thu, 30 Sep 2021 13:01:02 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=LWU3lFvKccyPrK+7SyNa/ZrfC78y7k5JZIU1I52Nquo=; b=Sw0FV5vxCKm0snDuBH2iqAtsPPKOtsuK+P5tRcGw0UrSQ1b5AVoj/b7Ffts7oH8NQ2 ffYaJ6YmyVFfZEChmucbadd2GtzuMr6EnSlHonlAP27dHXLPbovTO17OArvqyrWcVwAd +bAGFu6bLLqbr4CtYQDSHdt38k9lwCNFUWmrOLWkMrjuVMwKNl5nSuRambCYB3t2Ol97 BCJcak/Z6UknAz5iWOXL5rWE6vXmOFLVAn4E/6KHhFExgNmSzIzYal2oo60lyXKNihq5 RSMVmQEKmShKAB9bqa6iUpArnZOPW2wgAQTmmVNswhEDvha5+reqP9I7E74ZQbspyUZG 41nQ== X-Gm-Message-State: AOAM531zn6rjt/xGM/gXIiAkkwXAZhspJFHG7Mi+Z7XSfpmd6Ov6kwWE VyunKFzMMDl93ZH0M9Hb7uY4shptYT+BkQ== X-Google-Smtp-Source: ABdhPJxtR2LavbRU7fb6kD0jxdKr9wHblf3DQBnxigupkPQ5eAweBGIuz03n2svFCm1jukz+pJZRbw== X-Received: by 2002:ac8:435e:: with SMTP id a30mr8701596qtn.227.1633032061900; Thu, 30 Sep 2021 13:01:01 -0700 (PDT) Received: from birita.. ([2804:431:c7cb:b338:b20e:53f8:8b5:1bb2]) by smtp.gmail.com with ESMTPSA id r196sm1910203qka.119.2021.09.30.13.01.01 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 30 Sep 2021 13:01:01 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH 05/15] nptl: Replace struct thread cancelhandling field Date: Thu, 30 Sep 2021 17:00:41 -0300 Message-Id: <20210930200051.1017457-6-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210930200051.1017457-1-adhemerval.zanella@linaro.org> References: <20210930200051.1017457-1-adhemerval.zanella@linaro.org> MIME-Version: 1.0 X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) 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-Patchwork-Original-From: Adhemerval Zanella via Libc-alpha From: Adhemerval Zanella Netto Reply-To: Adhemerval Zanella Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Now that both thread state and setxid is being tracked by two different fields ('joinstate' and 'setxid_flag'), there is no need to keep track of exiting (EXITING_BIT) and terminated (TERMINATED_BIT) state in 'cancelhandling'. The 'cancelhandling' field is renamed to 'cancel_requested' and it only signals whether the thread has been cancelled (set by pthread_cancel()). It allows simplify the atomic operation required to avoid CAS operations. There is no need to check the thread state on __pthread_enable_asynccancel() nor on pthread_testcancel () anymore, since cancellation is explicitlly disabled when thread start the exit code on __do_cancel(). On __nptl_free_tcb(), the 'joinstate' now defines whether it is the creating thread or the created thread that calls it. So there is no concurrent call within the function and thus no need to set the TERMINATED_BIT. For SIGCANCEL handler, sigcancel_handler(), 'joinstate' is used instead (pthread_cancel() might still be called concurrenty in asynchronous mode). Checked on x86_64-linux-gnu and aarch64-linux-gnu. --- nptl/Versions | 1 + nptl/allocatestack.c | 2 +- nptl/cancellation.c | 10 ++-------- nptl/descr.h | 13 ++----------- nptl/nptl_free_tcb.c | 26 +++++++++++--------------- nptl/pthread_cancel.c | 10 ++++------ nptl/pthread_create.c | 10 ++-------- nptl/pthread_join_common.c | 10 +++------- nptl/pthread_testcancel.c | 10 ++-------- nptl_db/structs.def | 2 +- nptl_db/td_thr_get_info.c | 16 +++++++--------- nptl_db/td_thr_getfpregs.c | 9 +++++---- nptl_db/td_thr_getgregs.c | 9 +++++---- nptl_db/td_thr_setfpregs.c | 9 +++++---- nptl_db/td_thr_setgregs.c | 9 +++++---- sysdeps/hppa/nptl/tcb-offsets.sym | 1 - sysdeps/i386/nptl/tcb-offsets.sym | 1 - sysdeps/nptl/pthreadP.h | 3 --- sysdeps/sh/nptl/tcb-offsets.sym | 1 - sysdeps/x86_64/nptl/tcb-offsets.sym | 4 ---- 20 files changed, 56 insertions(+), 100 deletions(-) diff --git a/nptl/Versions b/nptl/Versions index 3221de89d1..3b23c6e248 100644 --- a/nptl/Versions +++ b/nptl/Versions @@ -413,6 +413,7 @@ libc { _thread_db_pthread_eventbuf; _thread_db_pthread_eventbuf_eventmask; _thread_db_pthread_eventbuf_eventmask_event_bits; + _thread_db_pthread_joinstate; _thread_db_pthread_key_data_data; _thread_db_pthread_key_data_level2_data; _thread_db_pthread_key_data_seq; diff --git a/nptl/allocatestack.c b/nptl/allocatestack.c index 74a8bbc19c..2b6baf583f 100644 --- a/nptl/allocatestack.c +++ b/nptl/allocatestack.c @@ -119,7 +119,7 @@ get_cached_stack (size_t *sizep, void **memp) *memp = result->stackblock; /* Cancellation handling is back to the default. */ - result->cancelhandling = 0; + result->cancel_requested = 0; result->cancelstate = PTHREAD_CANCEL_ENABLE; result->canceltype = PTHREAD_CANCEL_DEFERRED; result->cleanup = NULL; diff --git a/nptl/cancellation.c b/nptl/cancellation.c index 7cef9487bf..35c1b5c7e2 100644 --- a/nptl/cancellation.c +++ b/nptl/cancellation.c @@ -34,15 +34,9 @@ __pthread_enable_asynccancel (void) int oldval = THREAD_GETMEM (self, canceltype); THREAD_SETMEM (self, canceltype, PTHREAD_CANCEL_ASYNCHRONOUS); - int ch = THREAD_GETMEM (self, cancelhandling); - if (self->cancelstate == PTHREAD_CANCEL_ENABLE - && (ch & CANCELED_BITMASK) - && !(ch & EXITING_BITMASK) - && !(ch & TERMINATED_BITMASK)) - { - __do_cancel (); - } + && self->cancel_requested == 1) + __do_cancel (); return oldval; } diff --git a/nptl/descr.h b/nptl/descr.h index db011af500..6dc84ba47e 100644 --- a/nptl/descr.h +++ b/nptl/descr.h @@ -285,17 +285,8 @@ struct pthread struct pthread_unwind_buf *cleanup_jmp_buf; #define HAVE_CLEANUP_JMP_BUF - /* Flags determining processing of cancellation. */ - int cancelhandling; - /* Bit set if canceled. */ -#define CANCELED_BIT 3 -#define CANCELED_BITMASK (0x01 << CANCELED_BIT) - /* Bit set if thread is exiting. */ -#define EXITING_BIT 4 -#define EXITING_BITMASK (0x01 << EXITING_BIT) - /* Bit set if thread terminated and TCB is freed. */ -#define TERMINATED_BIT 5 -#define TERMINATED_BITMASK (0x01 << TERMINATED_BIT) + /* Flag to determine whether the thread is signaled to be cancelled. */ + int cancel_requested; /* Flags. Including those copied from the thread attribute. */ int flags; diff --git a/nptl/nptl_free_tcb.c b/nptl/nptl_free_tcb.c index 987a45f23c..56d5effae3 100644 --- a/nptl/nptl_free_tcb.c +++ b/nptl/nptl_free_tcb.c @@ -23,22 +23,18 @@ void __nptl_free_tcb (struct pthread *pd) { - /* The thread is exiting now. */ - if (atomic_bit_test_set (&pd->cancelhandling, TERMINATED_BIT) == 0) - { - /* Free TPP data. */ - if (pd->tpp != NULL) - { - struct priority_protection_data *tpp = pd->tpp; + /* Free TPP data. */ + if (pd->tpp != NULL) + { + struct priority_protection_data *tpp = pd->tpp; - pd->tpp = NULL; - free (tpp); - } + pd->tpp = NULL; + free (tpp); + } - /* Queue the stack memory block for reuse and exit the process. The - kernel will signal via writing to the address returned by - QUEUE-STACK when the stack is available. */ - __nptl_deallocate_stack (pd); - } + /* Queue the stack memory block for reuse and exit the process. The kernel + will signal via writing to the address of pthread 'joinstate' member + (due CLONE_CHILD_CLEARTID) when the child exits. */ + __nptl_deallocate_stack (pd); } libc_hidden_def (__nptl_free_tcb) diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c index d09947807e..f8cdbb6708 100644 --- a/nptl/pthread_cancel.c +++ b/nptl/pthread_cancel.c @@ -42,11 +42,8 @@ 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) + || atomic_load_relaxed (&self->joinstate) == THREAD_STATE_EXITING) return; /* Set the return value. */ @@ -93,8 +90,9 @@ __pthread_cancel (pthread_t th) } #endif - int oldch = atomic_fetch_or_acquire (&pd->cancelhandling, CANCELED_BITMASK); - if ((oldch & CANCELED_BITMASK) != 0) + /* If already cancelled just return (cancellation will be acted upon in next + cancellation entrypoint). */ + if (atomic_exchange_relaxed (&pd->cancel_requested, 1) == 1) return 0; if (pd == THREAD_SELF) diff --git a/nptl/pthread_create.c b/nptl/pthread_create.c index 3659f51c46..4ad5d8de26 100644 --- a/nptl/pthread_create.c +++ b/nptl/pthread_create.c @@ -478,12 +478,6 @@ start_thread (void *arg) } } - /* The thread is exiting now. Don't set this bit until after we've hit - the event-reporting breakpoint, so that td_thr_get_info on us while at - the breakpoint reports TD_THR_RUN state rather than TD_THR_ZOMBIE. */ - atomic_bit_set (&pd->cancelhandling, EXITING_BIT); - - /* CONCURRENCY NOTES: Concurrent pthread_detach() will either set state to @@ -569,8 +563,8 @@ start_thread (void *arg) do /* XXX This differs from the typical futex_wait_simple pattern in that the futex_wait condition (setxid_futex) is different from the - condition used in the surrounding loop (cancelhandling). We need - to check and document why this is correct. */ + condition used in the surrounding loop. We need to check and + document why this is correct. */ futex_wait_simple (&pd->setxid_futex, 0, FUTEX_PRIVATE); while (atomic_load_relaxed (&pd->setxid_flag) == 1); diff --git a/nptl/pthread_join_common.c b/nptl/pthread_join_common.c index 978ca56af6..3fed02d6be 100644 --- a/nptl/pthread_join_common.c +++ b/nptl/pthread_join_common.c @@ -33,14 +33,10 @@ check_for_deadlock (struct pthread *pd) { struct pthread *self = THREAD_SELF; return ((pd == self - || (atomic_load_acquire (&self->joinstate) == THREAD_STATE_DETACHED - && (pd->cancelhandling - & (CANCELED_BITMASK | EXITING_BITMASK - | TERMINATED_BITMASK)) == 0)) + || (atomic_load_acquire (&self->joinstate) + == THREAD_STATE_DETACHED)) && !(self->cancelstate == PTHREAD_CANCEL_ENABLE - && (pd->cancelhandling & (CANCELED_BITMASK | EXITING_BITMASK - | TERMINATED_BITMASK)) - == CANCELED_BITMASK)); + && atomic_load_relaxed (&self->cancel_requested) == 1)); } int diff --git a/nptl/pthread_testcancel.c b/nptl/pthread_testcancel.c index 6c613462ab..a45b8e3176 100644 --- a/nptl/pthread_testcancel.c +++ b/nptl/pthread_testcancel.c @@ -23,14 +23,8 @@ 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)) - { - __do_cancel (); - } + if (self->cancelstate == PTHREAD_CANCEL_ENABLE && self->cancel_requested == 1) + __do_cancel (); } versioned_symbol (libc, ___pthread_testcancel, pthread_testcancel, GLIBC_2_34); libc_hidden_ver (___pthread_testcancel, __pthread_testcancel) diff --git a/nptl_db/structs.def b/nptl_db/structs.def index 248ecf4335..65a068e9d1 100644 --- a/nptl_db/structs.def +++ b/nptl_db/structs.def @@ -53,7 +53,7 @@ DB_STRUCT_FIELD (pthread, list) DB_STRUCT_FIELD (pthread, report_events) DB_STRUCT_FIELD (pthread, tid) DB_STRUCT_FIELD (pthread, start_routine) -DB_STRUCT_FIELD (pthread, cancelhandling) +DB_STRUCT_FIELD (pthread, joinstate) DB_STRUCT_FIELD (pthread, schedpolicy) DB_STRUCT_FIELD (pthread, schedparam_sched_priority) DB_STRUCT_FIELD (pthread, specific) diff --git a/nptl_db/td_thr_get_info.c b/nptl_db/td_thr_get_info.c index 7d79bd4152..c3ab444a9f 100644 --- a/nptl_db/td_thr_get_info.c +++ b/nptl_db/td_thr_get_info.c @@ -27,7 +27,7 @@ td_thr_get_info (const td_thrhandle_t *th, td_thrinfo_t *infop) { td_err_e err; void *copy; - psaddr_t tls, schedpolicy, schedprio, cancelhandling, tid, report_events; + psaddr_t tls, schedpolicy, schedprio, joinstate, tid, report_events; LOG ("td_thr_get_info"); @@ -36,7 +36,7 @@ td_thr_get_info (const td_thrhandle_t *th, td_thrinfo_t *infop) /* Special case for the main thread before initialization. */ copy = NULL; tls = 0; - cancelhandling = 0; + joinstate = 0; schedpolicy = SCHED_OTHER; schedprio = 0; tid = 0; @@ -75,8 +75,8 @@ td_thr_get_info (const td_thrhandle_t *th, td_thrinfo_t *infop) err = DB_GET_FIELD_LOCAL (tid, th->th_ta_p, copy, pthread, tid, 0); if (err != TD_OK) return err; - err = DB_GET_FIELD_LOCAL (cancelhandling, th->th_ta_p, copy, pthread, - cancelhandling, 0); + err = DB_GET_FIELD_LOCAL (joinstate, th->th_ta_p, copy, pthread, + joinstate, 0); if (err != TD_OK) return err; err = DB_GET_FIELD_LOCAL (report_events, th->th_ta_p, copy, pthread, @@ -95,13 +95,11 @@ td_thr_get_info (const td_thrhandle_t *th, td_thrinfo_t *infop) ? 0 : (uintptr_t) schedprio); infop->ti_type = TD_THR_USER; - if ((((int) (uintptr_t) cancelhandling) & EXITING_BITMASK) == 0) - /* XXX For now there is no way to get more information. */ + int js = (int) (uintptr_t) joinstate; + if (js == THREAD_STATE_JOINABLE || js == THREAD_STATE_DETACHED) infop->ti_state = TD_THR_ACTIVE; - else if ((((int) (uintptr_t) cancelhandling) & TERMINATED_BITMASK) == 0) - infop->ti_state = TD_THR_ZOMBIE; else - infop->ti_state = TD_THR_UNKNOWN; + infop->ti_state = TD_THR_ZOMBIE; /* Initialization which are the same in both cases. */ infop->ti_ta_p = th->th_ta_p; diff --git a/nptl_db/td_thr_getfpregs.c b/nptl_db/td_thr_getfpregs.c index 4dc4e392e9..1429d9fd8f 100644 --- a/nptl_db/td_thr_getfpregs.c +++ b/nptl_db/td_thr_getfpregs.c @@ -22,7 +22,7 @@ td_err_e td_thr_getfpregs (const td_thrhandle_t *th, prfpregset_t *regset) { - psaddr_t cancelhandling, tid; + psaddr_t joinstate, tid; td_err_e err; LOG ("td_thr_getfpregs"); @@ -33,13 +33,14 @@ td_thr_getfpregs (const td_thrhandle_t *th, prfpregset_t *regset) regset) != PS_OK ? TD_ERR : TD_OK; /* We have to get the state and the PID for this thread. */ - err = DB_GET_FIELD (cancelhandling, th->th_ta_p, th->th_unique, pthread, - cancelhandling, 0); + err = DB_GET_FIELD (joinstate, th->th_ta_p, th->th_unique, pthread, + joinstate, 0); if (err != TD_OK) return err; /* If the thread already terminated we return all zeroes. */ - if (((int) (uintptr_t) cancelhandling) & TERMINATED_BITMASK) + int js = (int) (uintptr_t) joinstate; + if (js == THREAD_STATE_EXITING || js == THREAD_STATE_EXITED) memset (regset, '\0', sizeof (*regset)); /* Otherwise get the register content through the callback. */ else diff --git a/nptl_db/td_thr_getgregs.c b/nptl_db/td_thr_getgregs.c index 2dfa4fe3c2..1acabe9dc0 100644 --- a/nptl_db/td_thr_getgregs.c +++ b/nptl_db/td_thr_getgregs.c @@ -22,7 +22,7 @@ td_err_e td_thr_getgregs (const td_thrhandle_t *th, prgregset_t regset) { - psaddr_t cancelhandling, tid; + psaddr_t joinstate, tid; td_err_e err; LOG ("td_thr_getgregs"); @@ -33,13 +33,14 @@ td_thr_getgregs (const td_thrhandle_t *th, prgregset_t regset) regset) != PS_OK ? TD_ERR : TD_OK; /* We have to get the state and the PID for this thread. */ - err = DB_GET_FIELD (cancelhandling, th->th_ta_p, th->th_unique, pthread, - cancelhandling, 0); + err = DB_GET_FIELD (joinstate, th->th_ta_p, th->th_unique, pthread, + joinstate, 0); if (err != TD_OK) return err; /* If the thread already terminated we return all zeroes. */ - if (((int) (uintptr_t) cancelhandling) & TERMINATED_BITMASK) + int js = (int) (uintptr_t) joinstate; + if (js == THREAD_STATE_EXITING || js == THREAD_STATE_EXITED) memset (regset, '\0', sizeof (*regset)); /* Otherwise get the register content through the callback. */ else diff --git a/nptl_db/td_thr_setfpregs.c b/nptl_db/td_thr_setfpregs.c index f4dfc8b97a..04d148e0f4 100644 --- a/nptl_db/td_thr_setfpregs.c +++ b/nptl_db/td_thr_setfpregs.c @@ -22,7 +22,7 @@ td_err_e td_thr_setfpregs (const td_thrhandle_t *th, const prfpregset_t *fpregs) { - psaddr_t cancelhandling, tid; + psaddr_t joinstate, tid; td_err_e err; LOG ("td_thr_setfpregs"); @@ -33,13 +33,14 @@ td_thr_setfpregs (const td_thrhandle_t *th, const prfpregset_t *fpregs) fpregs) != PS_OK ? TD_ERR : TD_OK; /* We have to get the state and the PID for this thread. */ - err = DB_GET_FIELD (cancelhandling, th->th_ta_p, th->th_unique, pthread, - cancelhandling, 0); + err = DB_GET_FIELD (joinstate, th->th_ta_p, th->th_unique, pthread, + joinstate, 0); if (err != TD_OK) return err; /* Only set the registers if the thread hasn't yet terminated. */ - if ((((int) (uintptr_t) cancelhandling) & TERMINATED_BITMASK) == 0) + int js = (int) (uintptr_t) joinstate; + if (js != THREAD_STATE_EXITING || js != THREAD_STATE_EXITED) { err = DB_GET_FIELD (tid, th->th_ta_p, th->th_unique, pthread, tid, 0); if (err != TD_OK) diff --git a/nptl_db/td_thr_setgregs.c b/nptl_db/td_thr_setgregs.c index 2e5c20f0ea..50dd12b8b3 100644 --- a/nptl_db/td_thr_setgregs.c +++ b/nptl_db/td_thr_setgregs.c @@ -22,7 +22,7 @@ td_err_e td_thr_setgregs (const td_thrhandle_t *th, prgregset_t gregs) { - psaddr_t cancelhandling, tid; + psaddr_t joinstate, tid; td_err_e err; LOG ("td_thr_setgregs"); @@ -33,13 +33,14 @@ td_thr_setgregs (const td_thrhandle_t *th, prgregset_t gregs) gregs) != PS_OK ? TD_ERR : TD_OK; /* We have to get the state and the PID for this thread. */ - err = DB_GET_FIELD (cancelhandling, th->th_ta_p, th->th_unique, pthread, - cancelhandling, 0); + err = DB_GET_FIELD (joinstate, th->th_ta_p, th->th_unique, pthread, + joinstate, 0); if (err != TD_OK) return err; /* Only set the registers if the thread hasn't yet terminated. */ - if ((((int) (uintptr_t) cancelhandling) & TERMINATED_BITMASK) == 0) + int js = (int) (uintptr_t) joinstate; + if (js != THREAD_STATE_EXITING || js != THREAD_STATE_EXITED) { err = DB_GET_FIELD (tid, th->th_ta_p, th->th_unique, pthread, tid, 0); if (err != TD_OK) diff --git a/sysdeps/hppa/nptl/tcb-offsets.sym b/sysdeps/hppa/nptl/tcb-offsets.sym index 6e852f35b1..8937f1ec21 100644 --- a/sysdeps/hppa/nptl/tcb-offsets.sym +++ b/sysdeps/hppa/nptl/tcb-offsets.sym @@ -3,7 +3,6 @@ RESULT offsetof (struct pthread, result) TID offsetof (struct pthread, tid) -CANCELHANDLING offsetof (struct pthread, cancelhandling) CLEANUP_JMP_BUF offsetof (struct pthread, cleanup_jmp_buf) MULTIPLE_THREADS_OFFSET offsetof (struct pthread, header.multiple_threads) TLS_PRE_TCB_SIZE sizeof (struct pthread) diff --git a/sysdeps/i386/nptl/tcb-offsets.sym b/sysdeps/i386/nptl/tcb-offsets.sym index 2ec9e787c1..85a27dc29f 100644 --- a/sysdeps/i386/nptl/tcb-offsets.sym +++ b/sysdeps/i386/nptl/tcb-offsets.sym @@ -4,7 +4,6 @@ RESULT offsetof (struct pthread, result) TID offsetof (struct pthread, tid) -CANCELHANDLING offsetof (struct pthread, cancelhandling) CLEANUP_JMP_BUF offsetof (struct pthread, cleanup_jmp_buf) MULTIPLE_THREADS_OFFSET offsetof (tcbhead_t, multiple_threads) SYSINFO_OFFSET offsetof (tcbhead_t, sysinfo) diff --git a/sysdeps/nptl/pthreadP.h b/sysdeps/nptl/pthreadP.h index 8dfd55e87d..6427a11cd2 100644 --- a/sysdeps/nptl/pthreadP.h +++ b/sysdeps/nptl/pthreadP.h @@ -271,9 +271,6 @@ __exit_thread (void *value) { struct pthread *self = THREAD_SELF; - /* Make sure we get no more cancellations. */ - THREAD_ATOMIC_BIT_SET (self, cancelhandling, EXITING_BIT); - THREAD_SETMEM (self, result, value); /* It is required by POSIX XSH 2.9.5 Thread Cancellation under the heading diff --git a/sysdeps/sh/nptl/tcb-offsets.sym b/sysdeps/sh/nptl/tcb-offsets.sym index 234207779d..60c9e40b72 100644 --- a/sysdeps/sh/nptl/tcb-offsets.sym +++ b/sysdeps/sh/nptl/tcb-offsets.sym @@ -4,7 +4,6 @@ RESULT offsetof (struct pthread, result) TID offsetof (struct pthread, tid) -CANCELHANDLING offsetof (struct pthread, cancelhandling) CLEANUP_JMP_BUF offsetof (struct pthread, cleanup_jmp_buf) MULTIPLE_THREADS_OFFSET offsetof (struct pthread, header.multiple_threads) TLS_PRE_TCB_SIZE sizeof (struct pthread) diff --git a/sysdeps/x86_64/nptl/tcb-offsets.sym b/sysdeps/x86_64/nptl/tcb-offsets.sym index 2bbd563a6c..6cc845f7ed 100644 --- a/sysdeps/x86_64/nptl/tcb-offsets.sym +++ b/sysdeps/x86_64/nptl/tcb-offsets.sym @@ -4,7 +4,6 @@ RESULT offsetof (struct pthread, result) TID offsetof (struct pthread, tid) -CANCELHANDLING offsetof (struct pthread, cancelhandling) CLEANUP_JMP_BUF offsetof (struct pthread, cleanup_jmp_buf) CLEANUP offsetof (struct pthread, cleanup) CLEANUP_PREV offsetof (struct _pthread_cleanup_buffer, __prev) @@ -13,6 +12,3 @@ MULTIPLE_THREADS_OFFSET offsetof (tcbhead_t, multiple_threads) POINTER_GUARD offsetof (tcbhead_t, pointer_guard) FEATURE_1_OFFSET offsetof (tcbhead_t, feature_1) SSP_BASE_OFFSET offsetof (tcbhead_t, ssp_base) - --- Not strictly offsets, but these values are also used in the TCB. -TCB_CANCELED_BITMASK CANCELED_BITMASK