2 Unix SMB/CIFS implementation.
4 common events code for signal events
6 Copyright (C) Andrew Tridgell 2007
8 ** NOTE! The following LGPL license applies to the tevent
9 ** library. This does NOT imply that all of Samba is released
12 This library is free software; you can redistribute it and/or
13 modify it under the terms of the GNU Lesser General Public
14 License as published by the Free Software Foundation; either
15 version 3 of the License, or (at your option) any later version.
17 This library is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 Lesser General Public License for more details.
22 You should have received a copy of the GNU Lesser General Public
23 License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 #include "system/filesys.h"
28 #include "system/wait.h"
30 #include "tevent_internal.h"
31 #include "tevent_util.h"
33 #define NUM_SIGNALS 64
35 /* maximum number of SA_SIGINFO signals to hold in the queue */
36 #define SA_INFO_QUEUE_COUNT 100
43 #define SIG_INCREMENT(s) (s).count++
44 #define SIG_SEEN(s, n) (s).seen += (n)
45 #define SIG_PENDING(s) ((s).seen != (s).count)
47 struct tevent_common_signal_list {
48 struct tevent_common_signal_list *prev, *next;
49 struct tevent_signal *se;
53 the poor design of signals means that this table must be static global
55 static struct sig_state {
56 struct tevent_common_signal_list *sig_handlers[NUM_SIGNALS+1];
57 struct sigaction *oldact[NUM_SIGNALS+1];
58 struct sigcounter signal_count[NUM_SIGNALS+1];
59 struct sigcounter got_signal;
62 /* with SA_SIGINFO we get quite a lot of info per signal */
63 siginfo_t *sig_info[NUM_SIGNALS+1];
64 struct sigcounter sig_blocked[NUM_SIGNALS+1];
69 return number of sigcounter events not processed yet
71 static uint32_t sig_count(struct sigcounter s)
73 if (s.count >= s.seen) {
74 return s.count - s.seen;
76 return 1 + (0xFFFFFFFF & ~(s.seen - s.count));
80 signal handler - redirects to registered signals
82 static void tevent_common_signal_handler(int signum)
86 SIG_INCREMENT(sig_state->signal_count[signum]);
87 SIG_INCREMENT(sig_state->got_signal);
88 /* doesn't matter if this pipe overflows */
89 res = write(sig_state->pipe_hack[1], &c, 1);
94 signal handler with SA_SIGINFO - redirects to registered signals
96 static void tevent_common_signal_handler_info(int signum, siginfo_t *info,
99 uint32_t count = sig_count(sig_state->signal_count[signum]);
100 /* sig_state->signal_count[signum].seen % SA_INFO_QUEUE_COUNT
101 * is the base of the unprocessed signals in the ringbuffer. */
102 uint32_t ofs = (sig_state->signal_count[signum].seen + count) %
104 sig_state->sig_info[signum][ofs] = *info;
106 tevent_common_signal_handler(signum);
108 /* handle SA_SIGINFO */
109 if (count+1 == SA_INFO_QUEUE_COUNT) {
110 /* we've filled the info array - block this signal until
111 these ones are delivered */
114 sigaddset(&set, signum);
115 sigprocmask(SIG_BLOCK, &set, NULL);
116 SIG_INCREMENT(sig_state->sig_blocked[signum]);
121 static int tevent_common_signal_list_destructor(struct tevent_common_signal_list *sl)
123 DLIST_REMOVE(sig_state->sig_handlers[sl->se->signum], sl);
128 destroy a signal event
130 static int tevent_signal_destructor(struct tevent_signal *se)
132 struct tevent_common_signal_list *sl;
133 sl = talloc_get_type(se->additional_data,
134 struct tevent_common_signal_list);
137 DLIST_REMOVE(se->event_ctx->signal_events, se);
142 if (sig_state->sig_handlers[se->signum] == NULL) {
143 /* restore old handler, if any */
144 sigaction(se->signum, sig_state->oldact[se->signum], NULL);
145 sig_state->oldact[se->signum] = NULL;
147 if (se->sa_flags & SA_SIGINFO) {
148 talloc_free(sig_state->sig_info[se->signum]);
149 sig_state->sig_info[se->signum] = NULL;
158 this is part of the pipe hack needed to avoid the signal race condition
160 static void signal_pipe_handler(struct tevent_context *ev, struct tevent_fd *fde,
161 uint16_t flags, void *private)
165 /* its non-blocking, doesn't matter if we read too much */
166 res = read(sig_state->pipe_hack[0], c, sizeof(c));
171 return NULL on failure (memory allocation error)
173 struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
177 tevent_signal_handler_t handler,
179 const char *handler_name,
180 const char *location)
182 struct tevent_signal *se;
183 struct tevent_common_signal_list *sl;
185 if (signum >= NUM_SIGNALS) {
190 /* the sig_state needs to be on a global context as it can last across
191 multiple event contexts */
192 if (sig_state == NULL) {
193 sig_state = talloc_zero(talloc_autofree_context(), struct sig_state);
194 if (sig_state == NULL) {
199 se = talloc(mem_ctx?mem_ctx:ev, struct tevent_signal);
200 if (se == NULL) return NULL;
204 se->sa_flags = sa_flags;
205 se->handler = handler;
206 se->private_data = private_data;
207 se->handler_name = handler_name;
208 se->location = location;
209 se->additional_data = NULL;
211 sl = talloc(se, struct tevent_common_signal_list);
217 se->additional_data = sl;
219 /* Ensure, no matter the destruction order, that we always have a handle on the global sig_state */
220 if (!talloc_reference(se, sig_state)) {
225 /* only install a signal handler if not already installed */
226 if (sig_state->sig_handlers[signum] == NULL) {
227 struct sigaction act;
229 act.sa_handler = tevent_common_signal_handler;
230 act.sa_flags = sa_flags;
232 if (sa_flags & SA_SIGINFO) {
233 act.sa_handler = NULL;
234 act.sa_sigaction = tevent_common_signal_handler_info;
235 if (sig_state->sig_info[signum] == NULL) {
236 sig_state->sig_info[signum] = talloc_zero_array(sig_state, siginfo_t, SA_INFO_QUEUE_COUNT);
237 if (sig_state->sig_info[signum] == NULL) {
244 sig_state->oldact[signum] = talloc(sig_state, struct sigaction);
245 if (sig_state->oldact[signum] == NULL) {
249 if (sigaction(signum, &act, sig_state->oldact[signum]) == -1) {
255 DLIST_ADD(se->event_ctx->signal_events, se);
256 DLIST_ADD(sig_state->sig_handlers[signum], sl);
258 talloc_set_destructor(se, tevent_signal_destructor);
259 talloc_set_destructor(sl, tevent_common_signal_list_destructor);
261 /* we need to setup the pipe hack handler if not already
263 if (ev->pipe_fde == NULL) {
264 if (sig_state->pipe_hack[0] == 0 &&
265 sig_state->pipe_hack[1] == 0) {
266 if (pipe(sig_state->pipe_hack) == -1) {
270 ev_set_blocking(sig_state->pipe_hack[0], false);
271 ev_set_blocking(sig_state->pipe_hack[1], false);
273 ev->pipe_fde = tevent_add_fd(ev, ev, sig_state->pipe_hack[0],
274 TEVENT_FD_READ, signal_pipe_handler, NULL);
286 check if a signal is pending
287 return != 0 if a signal was pending
289 int tevent_common_check_signal(struct tevent_context *ev)
293 if (!sig_state || !SIG_PENDING(sig_state->got_signal)) {
297 for (i=0;i<NUM_SIGNALS+1;i++) {
298 struct tevent_common_signal_list *sl, *next;
299 struct sigcounter counter = sig_state->signal_count[i];
300 uint32_t count = sig_count(counter);
302 /* Ensure we null out any stored siginfo_t entries
303 * after processing for debugging purposes. */
304 bool clear_processed_siginfo = false;
310 for (sl=sig_state->sig_handlers[i];sl;sl=next) {
311 struct tevent_signal *se = sl->se;
314 if (se->sa_flags & SA_SIGINFO) {
317 clear_processed_siginfo = true;
319 for (j=0;j<count;j++) {
320 /* sig_state->signal_count[i].seen
321 * % SA_INFO_QUEUE_COUNT is
322 * the base position of the unprocessed
323 * signals in the ringbuffer. */
324 uint32_t ofs = (counter.seen + j)
325 % SA_INFO_QUEUE_COUNT;
326 se->handler(ev, se, i, 1,
327 (void*)&sig_state->sig_info[i][ofs],
330 if (se->sa_flags & SA_RESETHAND) {
336 se->handler(ev, se, i, count, NULL, se->private_data);
337 if (se->sa_flags & SA_RESETHAND) {
343 if (clear_processed_siginfo) {
345 for (j=0;j<count;j++) {
346 uint32_t ofs = (counter.seen + j)
347 % SA_INFO_QUEUE_COUNT;
348 memset((void*)&sig_state->sig_info[i][ofs],
355 SIG_SEEN(sig_state->signal_count[i], count);
356 SIG_SEEN(sig_state->got_signal, count);
359 if (SIG_PENDING(sig_state->sig_blocked[i])) {
360 /* We'd filled the queue, unblock the
361 signal now the queue is empty again.
362 Note we MUST do this after the
363 SIG_SEEN(sig_state->signal_count[i], count)
364 call to prevent a new signal running
365 out of room in the sig_state->sig_info[i][]
370 SIG_SEEN(sig_state->sig_blocked[i],
371 sig_count(sig_state->sig_blocked[i]));
372 sigprocmask(SIG_UNBLOCK, &set, NULL);