1/* Copyright (C) 2002-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <errno.h>
20#include <signal.h>
21#include <stdlib.h>
22#include "pthreadP.h"
23#include <atomic.h>
24#include <sysdep.h>
25#include <unistd.h>
26
27int
28__pthread_cancel (pthread_t th)
29{
30 volatile struct pthread *pd = (volatile struct pthread *) th;
31
32 /* Make sure the descriptor is valid. */
33 if (INVALID_TD_P (pd))
34 /* Not a valid thread handle. */
35 return ESRCH;
36
37#ifdef SHARED
38 pthread_cancel_init ();
39#endif
40 int result = 0;
41 int oldval;
42 int newval;
43 do
44 {
45 again:
46 oldval = pd->cancelhandling;
47 newval = oldval | CANCELING_BITMASK | CANCELED_BITMASK;
48
49 /* Avoid doing unnecessary work. The atomic operation can
50 potentially be expensive if the bug has to be locked and
51 remote cache lines have to be invalidated. */
52 if (oldval == newval)
53 break;
54
55 /* If the cancellation is handled asynchronously just send a
56 signal. We avoid this if possible since it's more
57 expensive. */
58 if (CANCEL_ENABLED_AND_CANCELED_AND_ASYNCHRONOUS (newval))
59 {
60 /* Mark the cancellation as "in progress". */
61 if (atomic_compare_and_exchange_bool_acq (&pd->cancelhandling,
62 oldval | CANCELING_BITMASK,
63 oldval))
64 goto again;
65
66#ifdef SIGCANCEL
67 /* The cancellation handler will take care of marking the
68 thread as canceled. */
69 pid_t pid = __getpid ();
70
71 INTERNAL_SYSCALL_DECL (err);
72 int val = INTERNAL_SYSCALL_CALL (tgkill, err, pid, pd->tid,
73 SIGCANCEL);
74 if (INTERNAL_SYSCALL_ERROR_P (val, err))
75 result = INTERNAL_SYSCALL_ERRNO (val, err);
76#else
77 /* It should be impossible to get here at all, since
78 pthread_setcanceltype should never have allowed
79 PTHREAD_CANCEL_ASYNCHRONOUS to be set. */
80 abort ();
81#endif
82
83 break;
84 }
85
86 /* A single-threaded process should be able to kill itself, since
87 there is nothing in the POSIX specification that says that it
88 cannot. So we set multiple_threads to true so that cancellation
89 points get executed. */
90 THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1);
91#ifndef TLS_MULTIPLE_THREADS_IN_TCB
92 __pthread_multiple_threads = *__libc_multiple_threads_ptr = 1;
93#endif
94 }
95 /* Mark the thread as canceled. This has to be done
96 atomically since other bits could be modified as well. */
97 while (atomic_compare_and_exchange_bool_acq (&pd->cancelhandling, newval,
98 oldval));
99
100 return result;
101}
102weak_alias (__pthread_cancel, pthread_cancel)
103
104PTHREAD_STATIC_FN_REQUIRE (__pthread_create)
105