Back to index

glibc  2.9
Functions
pthread_cancel.c File Reference
#include <errno.h>
#include <signal.h>
#include "pthreadP.h"
#include "atomic.h"
#include <sysdep.h>
#include <kernel-features.h>

Go to the source code of this file.

Functions

int pthread_cancel (pthread_t th)

Function Documentation

Definition at line 29 of file pthread_cancel.c.

{
  volatile struct pthread *pd = (volatile struct pthread *) th;

  /* 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
    {
      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
        remote cache lines have to be invalidated.  */
      if (oldval == newval)
       break;

      /* If the cancellation is handled asynchronously just send a
        signal.  We avoid this if possible since it's more
        expensive.  */
      if (CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS (newval))
       {
         /* Mark the cancellation as "in progress".  */
         atomic_bit_set (&pd->cancelhandling, CANCELING_BIT);

         /* The cancellation handler will take care of marking the
            thread as canceled.  */
         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;
#if __ASSUME_TGKILL
         val = INTERNAL_SYSCALL (tgkill, err, 3,
                              THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
                              SIGCANCEL);
#else
# ifdef __NR_tgkill
         val = INTERNAL_SYSCALL (tgkill, err, 3,
                              THREAD_GETMEM (THREAD_SELF, pid), pd->tid,
                              SIGCANCEL);
         if (INTERNAL_SYSCALL_ERROR_P (val, err)
             && INTERNAL_SYSCALL_ERRNO (val, err) == ENOSYS)
# endif
           val = INTERNAL_SYSCALL (tkill, err, 2, pd->tid, SIGCANCEL);
#endif

         if (INTERNAL_SYSCALL_ERROR_P (val, err))
           result = INTERNAL_SYSCALL_ERRNO (val, err);

         break;
       }
    }
  /* 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 result;
}

Here is the call graph for this function: