1/* Copyright (C) 2002-2021 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 <https://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 /* The cancellation handler will take care of marking the
67 thread as canceled. */
68 pid_t pid = __getpid ();
69
70 int val = INTERNAL_SYSCALL_CALL (tgkill, pid, pd->tid,
71 SIGCANCEL);
72 if (INTERNAL_SYSCALL_ERROR_P (val))
73 result = INTERNAL_SYSCALL_ERRNO (val);
74
75 break;
76 }
77
78 /* A single-threaded process should be able to kill itself, since
79 there is nothing in the POSIX specification that says that it
80 cannot. So we set multiple_threads to true so that cancellation
81 points get executed. */
82 THREAD_SETMEM (THREAD_SELF, header.multiple_threads, 1);
83#ifndef TLS_MULTIPLE_THREADS_IN_TCB
84 __pthread_multiple_threads = *__libc_multiple_threads_ptr = 1;
85#endif
86 }
87 /* Mark the thread as canceled. This has to be done
88 atomically since other bits could be modified as well. */
89 while (atomic_compare_and_exchange_bool_acq (&pd->cancelhandling, newval,
90 oldval));
91
92 return result;
93}
94weak_alias (__pthread_cancel, pthread_cancel)
95
96PTHREAD_STATIC_FN_REQUIRE (__pthread_create)
97