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#include <unwind-link.h>
27#include <stdio.h>
28#include <gnu/lib-names.h>
29#include <sys/single_threaded.h>
30
31/* For asynchronous cancellation we use a signal. */
32static void
33sigcancel_handler (int sig, siginfo_t *si, void *ctx)
34{
35 /* Safety check. It would be possible to call this function for
36 other signals and send a signal from another process. This is not
37 correct and might even be a security problem. Try to catch as
38 many incorrect invocations as possible. */
39 if (sig != SIGCANCEL
40 || si->si_pid != __getpid()
41 || si->si_code != SI_TKILL)
42 return;
43
44 struct pthread *self = THREAD_SELF;
45
46 int ch = atomic_load_relaxed (&self->cancelhandling);
47 /* Cancelation not enabled, not cancelled, or already exitting. */
48 if (self->cancelstate == PTHREAD_CANCEL_DISABLE
49 || (ch & CANCELED_BITMASK) == 0
50 || (ch & EXITING_BITMASK) != 0)
51 return;
52
53 /* Set the return value. */
54 THREAD_SETMEM (self, result, PTHREAD_CANCELED);
55 /* Make sure asynchronous cancellation is still enabled. */
56 if (self->canceltype == PTHREAD_CANCEL_ASYNCHRONOUS)
57 __do_cancel ();
58}
59
60int
61__pthread_cancel (pthread_t th)
62{
63 volatile struct pthread *pd = (volatile struct pthread *) th;
64
65 /* Make sure the descriptor is valid. */
66 if (INVALID_TD_P (pd))
67 /* Not a valid thread handle. */
68 return ESRCH;
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}
119versioned_symbol (libc, __pthread_cancel, pthread_cancel, GLIBC_2_34);
120
121#if OTHER_SHLIB_COMPAT (libpthread, GLIBC_2_0, GLIBC_2_34)
122compat_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. */
129PTHREAD_STATIC_FN_REQUIRE (___pthread_unwind_next)
130