From patchwork Mon Aug 23 19:50:30 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: 44751 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 12CB83858404 for ; Mon, 23 Aug 2021 19:55:06 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 12CB83858404 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1629748506; bh=jOXOsA+qniWV02QYO8wDQjZET8z7ylTh4QoIaIC8ZuY=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=Pk6A7bDStEmjb1pyp1s8bzBm1ZJut/UDF0dneLrjadG3qRH7k9HARLSNmZi7Rm9la yKPLDqwfszbqVzBUOvYo6VKGzz8trhBqRwNGuxYhduIjUPxvA5ztwRrvrmmskM6/MD h5z9W59O84wPk/ddCo7G8vYZuOElbCxupgHzYeI4= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-qk1-x72d.google.com (mail-qk1-x72d.google.com [IPv6:2607:f8b0:4864:20::72d]) by sourceware.org (Postfix) with ESMTPS id 01DA53858003 for ; Mon, 23 Aug 2021 19:50:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 01DA53858003 Received: by mail-qk1-x72d.google.com with SMTP id t4so6140622qkb.9 for ; Mon, 23 Aug 2021 12:50:53 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=jOXOsA+qniWV02QYO8wDQjZET8z7ylTh4QoIaIC8ZuY=; b=ov7PxYezvpuFFLQEdX9s0ahxn7CjdRQoNM13zNnQtCCvGr3ngCs1CZ0wiP3D2NXiQE 0i2YPm6n89RxxYThO0oaznVJqZXQf+FKEkvoCWSDLzD7xBPp2YM+sFMql6EoLDdf7kBv hKj+aiu1BncgvVnbwPCIDMY8PFchyU4wbKNuW7PoAD4OpgwEexep4LBsv0Ii7cAChIx8 A3hWsdkE24wsZ206pYLOGWCcho0sXZNsa3hNM9oIwFK6bt4Pd0u7l6poyQeDz5wiQH9/ U/oV5Dko1O2lpCNlNhQFfPx2jY7YD514gfPtC9L6MOo/X/VrqXQc4WGC9XgaqTUn0Aj9 NDoQ== X-Gm-Message-State: AOAM533/4qo5btPAXLoe0/2xXR3I6LmCYExhZwT8Esa/gIvSpkEJzVpu PInptv0HUnN8Y4HRMxBlxoqY7ZXJd/ZyqA== X-Google-Smtp-Source: ABdhPJycI35nSlTfCnhWtQ9A+KfJfcyhFKYB+JlRj3HkYGY/3ku+aT7W07Al5yb4ju3+58vUmWIHvw== X-Received: by 2002:a05:620a:28c6:: with SMTP id l6mr4503735qkp.325.1629748253379; Mon, 23 Aug 2021 12:50:53 -0700 (PDT) Received: from birita.. ([2804:431:c7ca:cd83:c38b:b50d:5d9a:43d4]) by smtp.gmail.com with ESMTPSA id s10sm9210935qko.134.2021.08.23.12.50.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 23 Aug 2021 12:50:53 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH v2 02/19] nptl: Set cancellation type and state on pthread_exit Date: Mon, 23 Aug 2021 16:50:30 -0300 Message-Id: <20210823195047.543237-3-adhemerval.zanella@linaro.org> X-Mailer: git-send-email 2.30.2 In-Reply-To: <20210823195047.543237-1-adhemerval.zanella@linaro.org> References: <20210823195047.543237-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, KAM_SHORT, 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 Cc: Florian Weimer Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" It is required by POSIX XSH 2.9.5 Thread Cancellation under the heading Thread Cancellation Cleanup Handlers. Checked x86_64-linux-gnu. --- nptl/Makefile | 3 +- nptl/cancellation.c | 7 +- nptl/pthread_cancel.c | 1 - nptl/pthread_exit.c | 4 +- nptl/pthread_testcancel.c | 1 - nptl/tst-cleanup5.c | 157 ++++++++++++++++++++++++++++++++++++++ sysdeps/nptl/pthreadP.h | 18 ++++- 7 files changed, 180 insertions(+), 11 deletions(-) create mode 100644 nptl/tst-cleanup5.c diff --git a/nptl/Makefile b/nptl/Makefile index ff4d590f11..e1e195cc15 100644 --- a/nptl/Makefile +++ b/nptl/Makefile @@ -306,7 +306,8 @@ tests = tst-attr2 tst-attr3 tst-default-attr \ tst-pthread-gdb-attach tst-pthread-gdb-attach-static \ tst-pthread_exit-nothreads \ tst-pthread_exit-nothreads-static \ - tst-thread-setspecific + tst-thread-setspecific \ + tst-cleanup5 tests-nolibpthread = \ tst-pthread_exit-nothreads \ diff --git a/nptl/cancellation.c b/nptl/cancellation.c index 05962784d5..6478c029de 100644 --- a/nptl/cancellation.c +++ b/nptl/cancellation.c @@ -42,7 +42,6 @@ __pthread_enable_asynccancel (void) && !(ch & EXITING_BITMASK) && !(ch & TERMINATED_BITMASK)) { - THREAD_SETMEM (self, result, PTHREAD_CANCELED); __do_cancel (); } @@ -64,3 +63,9 @@ __pthread_disable_asynccancel (int oldtype) self->canceltype = PTHREAD_CANCEL_DEFERRED; } libc_hidden_def (__pthread_disable_asynccancel) + +void +__do_cancel (void) +{ + __exit_thread (PTHREAD_CANCELED); +} diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c index cc25ff21f3..38f637c5cf 100644 --- a/nptl/pthread_cancel.c +++ b/nptl/pthread_cancel.c @@ -107,7 +107,6 @@ __pthread_cancel (pthread_t th) __libc_multiple_threads = 1; #endif - THREAD_SETMEM (pd, result, PTHREAD_CANCELED); if (pd->cancelstate == PTHREAD_CANCEL_ENABLE && pd->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS) __do_cancel (); diff --git a/nptl/pthread_exit.c b/nptl/pthread_exit.c index 6abf66463e..978f4042ef 100644 --- a/nptl/pthread_exit.c +++ b/nptl/pthread_exit.c @@ -32,9 +32,7 @@ __pthread_exit (void *value) " must be installed for pthread_exit to work\n"); } - THREAD_SETMEM (THREAD_SELF, result, value); - - __do_cancel (); + __exit_thread (value); } libc_hidden_def (__pthread_exit) weak_alias (__pthread_exit, pthread_exit) diff --git a/nptl/pthread_testcancel.c b/nptl/pthread_testcancel.c index 31185d89f2..f728a35524 100644 --- a/nptl/pthread_testcancel.c +++ b/nptl/pthread_testcancel.c @@ -30,7 +30,6 @@ ___pthread_testcancel (void) && !(cancelhandling & EXITING_BITMASK) && !(cancelhandling & TERMINATED_BITMASK)) { - THREAD_SETMEM (self, result, PTHREAD_CANCELED); __do_cancel (); } } diff --git a/nptl/tst-cleanup5.c b/nptl/tst-cleanup5.c new file mode 100644 index 0000000000..6cc1c141e9 --- /dev/null +++ b/nptl/tst-cleanup5.c @@ -0,0 +1,157 @@ +/* Check if cancellation state and type is correctly set on thread exit. + Copyright (C) 2021 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 +#include +#include + +static int pipefds[2]; +static pthread_barrier_t b; + +static void +clh (void *arg) +{ + /* Although POSIX state setting either the cancellation state or type is + undefined during cleanup handler execution, both calls should be safe + since none has any side-effect (they should not change current state + neither trigger a pending cancellation). */ + + int state; + TEST_VERIFY (pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &state) == 0); + TEST_COMPARE (state, PTHREAD_CANCEL_DISABLE); + + int type; + TEST_VERIFY (pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, &type) == 0); + TEST_COMPARE (type, PTHREAD_CANCEL_DEFERRED); +} + +/* Check if a thread with PTHREAD_CANCEL_DEFERRED cancellation on + pthread_cleanup_pop sets the correct state and type as pthread_exit. */ +static void * +tf_cancel_deferred (void *arg) +{ + xpthread_barrier_wait (&b); + + pthread_cleanup_push (clh, NULL); + + char c; + read (pipefds[0], &c, 1); + + pthread_cleanup_pop (1); + + return NULL; +} + +/* Check if a thread with PTHREAD_CANCEL_ASYNCHRONOUS cancellation on + blocked read() sets the correct state and type as pthread_exit. */ +static void * +tf_cancel_async (void *arg) +{ + TEST_VERIFY (pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, NULL) + == 0); + + xpthread_barrier_wait (&b); + + pthread_cleanup_push (clh, NULL); + + char c; + read (pipefds[0], &c, 1); + + pthread_cleanup_pop (1); + + return NULL; +} + +/* Check if a thread with PTHREAD_CANCEL_DEFERRED cancellation on + blocked read() sets the correct state and type as pthread_exit. */ +static void * +tf_testcancel (void *arg) +{ + xpthread_barrier_wait (&b); + + pthread_cleanup_push (clh, NULL); + + char c; + read (pipefds[0], &c, 1); + + pthread_testcancel (); + + pthread_cleanup_pop (1); + + return NULL; +} + +#define EXIT_EXPECTED_VALUE ((void *) 42) + +/* Check if a thread with PTHREAD_CANCEL_DEFERRED cancellation on + pthread_exit() sets the correct state and type. */ +static void * +tf_exit (void *arg) +{ + xpthread_barrier_wait (&b); + + pthread_cleanup_push (clh, NULL); + + pthread_exit (EXIT_EXPECTED_VALUE); + + pthread_cleanup_pop (1); + + return NULL; +} + +static int +do_test (void) +{ + xpipe (pipefds); + + xpthread_barrier_init (&b, NULL, 2); + { + pthread_t th = xpthread_create (NULL, tf_cancel_deferred, NULL); + xpthread_barrier_wait (&b); + xpthread_cancel (th); + void *r = xpthread_join (th); + TEST_VERIFY (r == PTHREAD_CANCELED); + } + + { + pthread_t th = xpthread_create (NULL, tf_cancel_async, NULL); + xpthread_barrier_wait (&b); + xpthread_cancel (th); + void *r = xpthread_join (th); + TEST_VERIFY (r == PTHREAD_CANCELED); + } + + { + pthread_t th = xpthread_create (NULL, tf_testcancel, NULL); + xpthread_barrier_wait (&b); + xpthread_cancel (th); + void *r = xpthread_join (th); + TEST_VERIFY (r == PTHREAD_CANCELED); + } + + { + pthread_t th = xpthread_create (NULL, tf_exit, NULL); + xpthread_barrier_wait (&b); + void *r = xpthread_join (th); + TEST_VERIFY (r == EXIT_EXPECTED_VALUE); + } + + return 0; +} + +#include diff --git a/sysdeps/nptl/pthreadP.h b/sysdeps/nptl/pthreadP.h index 374657a2fd..d968a91cfd 100644 --- a/sysdeps/nptl/pthreadP.h +++ b/sysdeps/nptl/pthreadP.h @@ -268,20 +268,30 @@ extern void __pthread_unregister_cancel (__pthread_unwind_buf_t *__buf) __cleanup_fct_attribute; libc_hidden_proto (__pthread_unregister_cancel) -/* Called when a thread reacts on a cancellation request. */ -static inline void -__attribute ((noreturn, always_inline)) -__do_cancel (void) +static _Noreturn inline void +__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 + Thread Cancellation Cleanup Handlers and also avoid further cancellation + wrapper to act on cancellation. */ + THREAD_SETMEM (self, cancelstate, PTHREAD_CANCEL_DISABLE); + THREAD_SETMEM (self, canceltype, PTHREAD_CANCEL_DEFERRED); + __pthread_unwind ((__pthread_unwind_buf_t *) THREAD_GETMEM (self, cleanup_jmp_buf)); } +/* It is a wrapper over __exit_thread (PTHREAD_CANCELED). It is has its own + implementation because it might be called by arch-specific asm code. */ +_Noreturn void __do_cancel (void) attribute_hidden; + /* Internal prototypes. */