mirror of
https://sourceware.org/git/glibc.git
synced 2024-12-11 05:40:06 +00:00
290db09546
Some Linux interfaces never restart after being interrupted by a signal handler, regardless of the use of SA_RESTART [1]. It means that for pthread cancellation, if the target thread disables cancellation with pthread_setcancelstate and calls such interfaces (like poll or select), it should not see spurious EINTR failures due the internal SIGCANCEL. However recent changes made pthread_cancel to always sent the internal signal, regardless of the target thread cancellation status or type. To fix it, the previous semantic is restored, where the cancel signal is only sent if the target thread has cancelation enabled in asynchronous mode. The cancel state and cancel type is moved back to cancelhandling and atomic operation are used to synchronize between threads. The patch essentially revert the following commits:8c1c0aae20nptl: Move cancel type out of cancelhandling2b51742531nptl: Move cancel state out of cancelhandling26cfbb7162nptl: Remove CANCELING_BITMASK However I changed the atomic operation to follow the internal C11 semantic and removed the MACRO usage, it simplifies a bit the resulting code (and removes another usage of the old atomic macros). Checked on x86_64-linux-gnu, i686-linux-gnu, aarch64-linux-gnu, and powerpc64-linux-gnu. [1] https://man7.org/linux/man-pages/man7/signal.7.html Reviewed-by: Florian Weimer <fweimer@redhat.com> Tested-by: Aurelien Jarno <aurelien@aurel32.net> (cherry-picked from commit404656009b)
93 lines
2.9 KiB
C
93 lines
2.9 KiB
C
/* Copyright (C) 2002-2021 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
|
|
|
|
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
|
|
<https://www.gnu.org/licenses/>. */
|
|
|
|
#include <setjmp.h>
|
|
#include <stdlib.h>
|
|
#include "pthreadP.h"
|
|
#include <futex-internal.h>
|
|
|
|
|
|
/* The next two functions are similar to pthread_setcanceltype() but
|
|
more specialized for the use in the cancelable functions like write().
|
|
They do not need to check parameters etc. These functions must be
|
|
AS-safe, with the exception of the actual cancellation, because they
|
|
are called by wrappers around AS-safe functions like write().*/
|
|
int
|
|
__pthread_enable_asynccancel (void)
|
|
{
|
|
struct pthread *self = THREAD_SELF;
|
|
int oldval = atomic_load_relaxed (&self->cancelhandling);
|
|
|
|
while (1)
|
|
{
|
|
int newval = oldval | CANCELTYPE_BITMASK;
|
|
|
|
if (newval == oldval)
|
|
break;
|
|
|
|
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;
|
|
}
|
|
libc_hidden_def (__pthread_enable_asynccancel)
|
|
|
|
/* See the comment for __pthread_enable_asynccancel regarding
|
|
the AS-safety of this function. */
|
|
void
|
|
__pthread_disable_asynccancel (int oldtype)
|
|
{
|
|
/* If asynchronous cancellation was enabled before we do not have
|
|
anything to do. */
|
|
if (oldtype & CANCELTYPE_BITMASK)
|
|
return;
|
|
|
|
struct pthread *self = THREAD_SELF;
|
|
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)
|