1/* Copyright (C) 2003-2020 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
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 License as
7 published by the Free Software Foundation; either version 2.1 of the
8 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; see the file COPYING.LIB. If
17 not, see <https://www.gnu.org/licenses/>. */
18
19#include <errno.h>
20#include <setjmp.h>
21#include <signal.h>
22#include <stdbool.h>
23#include <sysdep-cancel.h>
24#include <nptl/pthreadP.h>
25#include "kernel-posix-timers.h"
26
27
28/* List of active SIGEV_THREAD timers. */
29struct timer *__active_timer_sigev_thread;
30/* Lock for the __active_timer_sigev_thread. */
31pthread_mutex_t __active_timer_sigev_thread_lock = PTHREAD_MUTEX_INITIALIZER;
32
33
34struct thread_start_data
35{
36 void (*thrfunc) (sigval_t);
37 sigval_t sival;
38};
39
40
41/* Helper thread to call the user-provided function. */
42static void *
43timer_sigev_thread (void *arg)
44{
45 /* The parent thread has all signals blocked. This is a bit
46 surprising for user code, although valid. We unblock all
47 signals. */
48 sigset_t ss;
49 sigemptyset (&ss);
50 INTERNAL_SYSCALL_DECL (err);
51 INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &ss, NULL, _NSIG / 8);
52
53 struct thread_start_data *td = (struct thread_start_data *) arg;
54
55 void (*thrfunc) (sigval_t) = td->thrfunc;
56 sigval_t sival = td->sival;
57
58 /* The TD object was allocated in timer_helper_thread. */
59 free (td);
60
61 /* Call the user-provided function. */
62 thrfunc (sival);
63
64 return NULL;
65}
66
67
68/* Helper function to support starting threads for SIGEV_THREAD. */
69static void *
70timer_helper_thread (void *arg)
71{
72 /* Wait for the SIGTIMER signal, allowing the setXid signal, and
73 none else. */
74 sigset_t ss;
75 sigemptyset (&ss);
76 __sigaddset (&ss, SIGTIMER);
77
78 /* Endless loop of waiting for signals. The loop is only ended when
79 the thread is canceled. */
80 while (1)
81 {
82 siginfo_t si;
83
84 /* sigwaitinfo cannot be used here, since it deletes
85 SIGCANCEL == SIGTIMER from the set. */
86
87 /* XXX The size argument hopefully will have to be changed to the
88 real size of the user-level sigset_t. */
89 int result = SYSCALL_CANCEL (rt_sigtimedwait, &ss, &si, NULL, _NSIG / 8);
90
91 if (result > 0)
92 {
93 if (si.si_code == SI_TIMER)
94 {
95 struct timer *tk = (struct timer *) si.si_ptr;
96
97 /* Check the timer is still used and will not go away
98 while we are reading the values here. */
99 pthread_mutex_lock (&__active_timer_sigev_thread_lock);
100
101 struct timer *runp = __active_timer_sigev_thread;
102 while (runp != NULL)
103 if (runp == tk)
104 break;
105 else
106 runp = runp->next;
107
108 if (runp != NULL)
109 {
110 struct thread_start_data *td = malloc (sizeof (*td));
111
112 /* There is not much we can do if the allocation fails. */
113 if (td != NULL)
114 {
115 /* This is the signal we are waiting for. */
116 td->thrfunc = tk->thrfunc;
117 td->sival = tk->sival;
118
119 pthread_t th;
120 (void) pthread_create (&th, &tk->attr,
121 timer_sigev_thread, td);
122 }
123 }
124
125 pthread_mutex_unlock (&__active_timer_sigev_thread_lock);
126 }
127 else if (si.si_code == SI_TKILL)
128 /* The thread is canceled. */
129 pthread_exit (NULL);
130 }
131 }
132}
133
134
135/* Control variable for helper thread creation. */
136pthread_once_t __helper_once attribute_hidden;
137
138
139/* TID of the helper thread. */
140pid_t __helper_tid attribute_hidden;
141
142
143/* Reset variables so that after a fork a new helper thread gets started. */
144static void
145reset_helper_control (void)
146{
147 __helper_once = PTHREAD_ONCE_INIT;
148 __helper_tid = 0;
149}
150
151
152void
153attribute_hidden
154__start_helper_thread (void)
155{
156 /* The helper thread needs only very little resources
157 and should go away automatically when canceled. */
158 pthread_attr_t attr;
159 (void) pthread_attr_init (&attr);
160 (void) pthread_attr_setstacksize (&attr, __pthread_get_minstack (&attr));
161
162 /* Block all signals in the helper thread but SIGSETXID. To do this
163 thoroughly we temporarily have to block all signals here. The
164 helper can lose wakeups if SIGCANCEL is not blocked throughout,
165 but sigfillset omits it SIGSETXID. So, we add SIGCANCEL back
166 explicitly here. */
167 sigset_t ss;
168 sigset_t oss;
169 sigfillset (&ss);
170 __sigaddset (&ss, SIGCANCEL);
171 INTERNAL_SYSCALL_DECL (err);
172 INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &ss, &oss, _NSIG / 8);
173
174 /* Create the helper thread for this timer. */
175 pthread_t th;
176 int res = pthread_create (&th, &attr, timer_helper_thread, NULL);
177 if (res == 0)
178 /* We managed to start the helper thread. */
179 __helper_tid = ((struct pthread *) th)->tid;
180
181 /* Restore the signal mask. */
182 INTERNAL_SYSCALL (rt_sigprocmask, err, 4, SIG_SETMASK, &oss, NULL,
183 _NSIG / 8);
184
185 /* No need for the attribute anymore. */
186 (void) pthread_attr_destroy (&attr);
187
188 /* We have to make sure that after fork()ing a new helper thread can
189 be created. */
190 pthread_atfork (NULL, NULL, reset_helper_control);
191}
192