Update copyright dates with scripts/update-copyrights.

[thirdparty/glibc.git] / nptl / pthread_cancel.c

diff --git a/nptl/pthread_cancel.c b/nptl/pthread_cancel.c
index 0dd97a27e52bd1c36793f856168034ec9c26fc1d..1419baf98829fba85ab9b92b10d3f32c2276b367 100644 (file)
--- a/nptl/pthread_cancel.c
+++ b/nptl/pthread_cancel.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Copyright (C) 2002-2016 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
@@ -13,25 +13,38 @@
    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, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
 
+#include <errno.h>
 #include <signal.h>
+#include <stdlib.h>
 #include "pthreadP.h"
-#include "atomic.h"
+#include <atomic.h>
+#include <sysdep.h>
 
 
 int
-pthread_cancel (th)
-     pthread_t th;
+pthread_cancel (pthread_t th)
 {
   volatile struct pthread *pd = (volatile struct pthread *) th;
 
-  while (1)
+  /* Make sure the descriptor is valid.  */
+  if (INVALID_TD_P (pd))
+    /* Not a valid thread handle.  */
+    return ESRCH;
+
+#ifdef SHARED
+  pthread_cancel_init ();
+#endif
+  int result = 0;
+  int oldval;
+  int newval;
+  do
     {
-      int oldval = pd->cancelhandling;
-      int newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
+    again:
+      oldval = pd->cancelhandling;
+      newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
 
       /* Avoid doing unnecessary work.  The atomic operation can
         potentially be expensive if the bug has to be locked and
@@ -45,21 +58,54 @@ pthread_cancel (th)
       if (CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS (newval))
        {
          /* Mark the cancellation as "in progress".  */
-         atomic_bit_set (&pd->cancelhandling, CANCELING_BIT);
+         if (atomic_compare_and_exchange_bool_acq (&pd->cancelhandling,
+                                                   oldval | CANCELING_BITMASK,
+                                                   oldval))
+           goto again;
 
+#ifdef SIGCANCEL
          /* The cancellation handler will take care of marking the
             thread as canceled.  */
-         __pthread_kill (th, SIGCANCEL);
+         INTERNAL_SYSCALL_DECL (err);
+
+         /* One comment: The PID field in the TCB can temporarily be
+            changed (in fork).  But this must not affect this code
+            here.  Since this function would have to be called while
+            the thread is executing fork, it would have to happen in
+            a signal handler.  But this is no allowed, pthread_cancel
+            is not guaranteed to be async-safe.  */
+         int val;
+         val = INTERNAL_SYSCALL (tgkill, err, 3,
+                                 THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
+                                 SIGCANCEL);
+
+         if (INTERNAL_SYSCALL_ERROR_P (val, err))
+           result = INTERNAL_SYSCALL_ERRNO (val, err);
+#else
+          /* It should be impossible to get here at all, since
+             pthread_setcanceltype should never have allowed
+             PTHREAD_CANCEL_ASYNCHRONOUS to be set.  */
+          abort ();
+#endif
 
          break;
        }
 
-      /* Mark the thread as canceled.  This has to be done
-        atomically since other bits could be modified as well.  */
-      if (atomic_compare_and_exchange_acq (&pd->cancelhandling, newval,
-                                          oldval) == 0)
-       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
+       __pthread_multiple_threads = *__libc_multiple_threads_ptr = 1;
+#endif
     }
+  /* Mark the thread as canceled.  This has to be done
+     atomically since other bits could be modified as well.  */
+  while (atomic_compare_and_exchange_bool_acq (&pd->cancelhandling, newval,
+                                              oldval));
 
-  return 0;
+  return result;
 }
+
+PTHREAD_STATIC_FN_REQUIRE (pthread_create)