nptl/pthread_cancel.c

   1 /* Copyright (C) 2002-2021 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <errno.h>
  19 #include <signal.h>
  20 #include <stdlib.h>
  21 #include "pthreadP.h"
  22 #include <atomic.h>
  23 #include <sysdep.h>
  24 #include <unistd.h>
  25 #include <unwind-link.h>
  26 #include <stdio.h>
  27 #include <gnu/lib-names.h>
  28 #include <sys/single_threaded.h>
  29
  30 /* For asynchronous cancellation we use a signal.  */
  31 static void
  32 sigcancel_handler (int sig, siginfo_t *si, void *ctx)
  33 {
  34   /* Safety check.  It would be possible to call this function for
  35      other signals and send a signal from another process.  This is not
  36      correct and might even be a security problem.  Try to catch as
  37      many incorrect invocations as possible.  */
  38   if (sig != SIGCANCEL
  39       || si->si_pid != __getpid()
  40       || si->si_code != SI_TKILL)
  41     return;
  42
  43   struct pthread *self = THREAD_SELF;
  44
  45   int ch = atomic_load_relaxed (&self->cancelhandling);
  46   /* Cancelation not enabled, not cancelled, or already exitting.  */
  47   if (self->cancelstate == PTHREAD_CANCEL_DISABLE
  48       || (ch & CANCELED_BITMASK) == 0
  49       || (ch & EXITING_BITMASK) != 0)
  50     return;
  51
  52   /* Set the return value.  */
  53   THREAD_SETMEM (self, result, PTHREAD_CANCELED);
  54   /* Make sure asynchronous cancellation is still enabled.  */
  55   if (self->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)
  56     __do_cancel ();
  57 }
  58
  59 int
  60 __pthread_cancel (pthread_t th)
  61 {
  62   volatile struct pthread *pd = (volatile struct pthread *) th;
  63
  64   if (pd->tid == 0)
  65     /* The thread has already exited on the kernel side.  Its outcome
  66        (regular exit, other cancelation) has already been
  67        determined.  */
  68     return 0;
  69
  70   static int init_sigcancel = 0;
  71   if (atomic_load_relaxed (&init_sigcancel) == 0)
  72     {
  73       struct sigaction sa;
  74       sa.sa_sigaction = sigcancel_handler;
  75       /* The signal handle should be non-interruptible to avoid the risk of
  76          spurious EINTR caused by SIGCANCEL sent to process or if
  77          pthread_cancel() is called while cancellation is disabled in the
  78          target thread.  */
  79       sa.sa_flags = SA_SIGINFO | SA_RESTART;
  80       __sigemptyset (&sa.sa_mask);
  81       __libc_sigaction (SIGCANCEL, &sa, NULL);
  82       atomic_store_relaxed (&init_sigcancel, 1);
  83     }
  84
  85 #ifdef SHARED
  86   /* Trigger an error if libgcc_s cannot be loaded.  */
  87   {
  88     struct unwind_link *unwind_link = __libc_unwind_link_get ();
  89     if (unwind_link == NULL)
  90       __libc_fatal (LIBGCC_S_SO
  91                     " must be installed for pthread_cancel to work\n");
  92   }
  93 #endif
  94
  95   int oldch = atomic_fetch_or_acquire (&pd->cancelhandling, CANCELED_BITMASK);
  96   if ((oldch & CANCELED_BITMASK) != 0)
  97     return 0;
  98
  99   if (pd == THREAD_SELF)
 100     {
 101       /* A single-threaded process should be able to kill itself, since there
 102          is nothing in the POSIX specification that says that it cannot.  So
 103          we set multiple_threads to true so that cancellation points get
 104          executed.  */
 105       THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1);
 106 #ifndef TLS_MULTIPLE_THREADS_IN_TCB
 107       __libc_multiple_threads = 1;
 108 #endif
 109
 110       THREAD_SETMEM (pd, result, PTHREAD_CANCELED);
 111       if (pd->cancelstate == PTHREAD_CANCEL_ENABLE
 112           && pd->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)
 113         __do_cancel ();
 114       return 0;
 115     }
 116
 117   return __pthread_kill_internal (th, SIGCANCEL);
 118 }
 119 versioned_symbol (libc, __pthread_cancel, pthread_cancel, GLIBC_2_34);
 120
 121 #if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_34)
 122 compat_symbol (libpthread, __pthread_cancel, pthread_cancel, GLIBC_2_0);
 123 #endif
 124
 125 /* Ensure that the unwinder is always linked in (the __pthread_unwind
 126    reference from __do_cancel is weak).  Use ___pthread_unwind_next
 127    (three underscores) to produce a strong reference to the same
 128    file.  */
 129 PTHREAD_STATIC_FN_REQUIRE (___pthread_unwind_next)