2 Unix SMB/CIFS implementation.
4 common events code for signal events
6 Copyright (C) Andrew Tridgell 2007
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "system/filesys.h"
25 #include "system/select.h"
27 #include "events_internal.h"
29 #define NUM_SIGNALS 64
31 /* maximum number of SA_SIGINFO signals to hold in the queue */
32 #define SA_INFO_QUEUE_COUNT 10
39 #define SIG_INCREMENT(s) (s).count++
40 #define SIG_SEEN(s, n) (s).seen += (n)
41 #define SIG_PENDING(s) ((s).seen != (s).count)
45 the poor design of signals means that this table must be static global
47 static struct sig_state
{
48 struct signal_event
*sig_handlers
[NUM_SIGNALS
];
49 struct sigaction
*oldact
[NUM_SIGNALS
];
50 struct sigcounter signal_count
[NUM_SIGNALS
];
51 struct sigcounter got_signal
;
54 /* with SA_SIGINFO we get quite a lot of info per signal */
55 siginfo_t
*sig_info
[NUM_SIGNALS
];
56 struct sigcounter sig_blocked
[NUM_SIGNALS
];
61 return number of sigcounter events not processed yet
63 static uint32_t sig_count(struct sigcounter s
)
65 if (s
.count
>= s
.seen
) {
66 return s
.count
- s
.seen
;
68 return 1 + (0xFFFFFFFF & ~(s
.seen
- s
.count
));
72 signal handler - redirects to registered signals
74 static void signal_handler(int signum
)
77 SIG_INCREMENT(sig_state
->signal_count
[signum
]);
78 SIG_INCREMENT(sig_state
->got_signal
);
79 /* doesn't matter if this pipe overflows */
80 write(sig_state
->pipe_hack
[1], &c
, 1);
85 signal handler with SA_SIGINFO - redirects to registered signals
87 static void signal_handler_info(int signum
, siginfo_t
*info
, void *uctx
)
89 uint32_t count
= sig_count(sig_state
->signal_count
[signum
]);
90 sig_state
->sig_info
[signum
][count
] = *info
;
92 signal_handler(signum
);
94 /* handle SA_SIGINFO */
95 if (count
+1 == SA_INFO_QUEUE_COUNT
) {
96 /* we've filled the info array - block this signal until
97 these ones are delivered */
100 sigaddset(&set
, signum
);
101 sigprocmask(SIG_BLOCK
, &set
, NULL
);
102 SIG_INCREMENT(sig_state
->sig_blocked
[signum
]);
108 destroy a signal event
110 static int signal_event_destructor(struct signal_event
*se
)
112 se
->event_ctx
->num_signal_handlers
--;
113 DLIST_REMOVE(sig_state
->sig_handlers
[se
->signum
], se
);
114 if (sig_state
->sig_handlers
[se
->signum
] == NULL
) {
115 /* restore old handler, if any */
116 sigaction(se
->signum
, sig_state
->oldact
[se
->signum
], NULL
);
117 sig_state
->oldact
[se
->signum
] = NULL
;
119 if (se
->sa_flags
& SA_SIGINFO
) {
120 talloc_free(sig_state
->sig_info
[se
->signum
]);
121 sig_state
->sig_info
[se
->signum
] = NULL
;
129 this is part of the pipe hack needed to avoid the signal race condition
131 static void signal_pipe_handler(struct event_context
*ev
, struct fd_event
*fde
,
132 uint16_t flags
, void *private)
135 /* its non-blocking, doesn't matter if we read too much */
136 read(sig_state
->pipe_hack
[0], c
, sizeof(c
));
141 return NULL on failure (memory allocation error)
143 struct signal_event
*common_event_add_signal(struct event_context
*ev
,
147 event_signal_handler_t handler
,
150 struct signal_event
*se
;
152 if (signum
>= NUM_SIGNALS
) {
156 /* the sig_state needs to be on a global context as it can last across
157 multiple event contexts */
158 if (sig_state
== NULL
) {
159 sig_state
= talloc_zero(talloc_autofree_context(), struct sig_state
);
160 if (sig_state
== NULL
) {
165 se
= talloc(mem_ctx
?mem_ctx
:ev
, struct signal_event
);
166 if (se
== NULL
) return NULL
;
169 se
->handler
= handler
;
170 se
->private_data
= private_data
;
172 se
->sa_flags
= sa_flags
;
174 /* Ensure, no matter the destruction order, that we always have a handle on the global sig_state */
175 if (!talloc_reference(se
, sig_state
)) {
179 /* only install a signal handler if not already installed */
180 if (sig_state
->sig_handlers
[signum
] == NULL
) {
181 struct sigaction act
;
183 act
.sa_handler
= signal_handler
;
184 act
.sa_flags
= sa_flags
;
186 if (sa_flags
& SA_SIGINFO
) {
187 act
.sa_handler
= NULL
;
188 act
.sa_sigaction
= signal_handler_info
;
189 if (sig_state
->sig_info
[signum
] == NULL
) {
190 sig_state
->sig_info
[signum
] = talloc_array(sig_state
, siginfo_t
, SA_INFO_QUEUE_COUNT
);
191 if (sig_state
->sig_info
[signum
] == NULL
) {
198 sig_state
->oldact
[signum
] = talloc(sig_state
, struct sigaction
);
199 if (sig_state
->oldact
[signum
] == NULL
) {
203 if (sigaction(signum
, &act
, sig_state
->oldact
[signum
]) == -1) {
209 DLIST_ADD(sig_state
->sig_handlers
[signum
], se
);
211 talloc_set_destructor(se
, signal_event_destructor
);
213 /* we need to setup the pipe hack handler if not already
215 if (ev
->pipe_fde
== NULL
) {
216 if (sig_state
->pipe_hack
[0] == 0 &&
217 sig_state
->pipe_hack
[1] == 0) {
218 pipe(sig_state
->pipe_hack
);
219 ev_set_blocking(sig_state
->pipe_hack
[0], false);
220 ev_set_blocking(sig_state
->pipe_hack
[1], false);
222 ev
->pipe_fde
= event_add_fd(ev
, ev
, sig_state
->pipe_hack
[0],
223 EVENT_FD_READ
, signal_pipe_handler
, NULL
);
225 ev
->num_signal_handlers
++;
232 check if a signal is pending
233 return != 0 if a signal was pending
235 int common_event_check_signal(struct event_context
*ev
)
239 if (!sig_state
|| !SIG_PENDING(sig_state
->got_signal
)) {
243 for (i
=0;i
<NUM_SIGNALS
+1;i
++) {
244 struct signal_event
*se
, *next
;
245 struct sigcounter counter
= sig_state
->signal_count
[i
];
246 uint32_t count
= sig_count(counter
);
251 for (se
=sig_state
->sig_handlers
[i
];se
;se
=next
) {
254 if (se
->sa_flags
& SA_SIGINFO
) {
256 for (j
=0;j
<count
;j
++) {
257 /* note the use of the sig_info array as a
259 int ofs
= ((count
-1) + j
) % SA_INFO_QUEUE_COUNT
;
260 se
->handler(ev
, se
, i
, 1,
261 (void*)&sig_state
->sig_info
[i
][ofs
],
264 if (SIG_PENDING(sig_state
->sig_blocked
[i
])) {
265 /* we'd filled the queue, unblock the
270 SIG_SEEN(sig_state
->sig_blocked
[i
],
271 sig_count(sig_state
->sig_blocked
[i
]));
272 sigprocmask(SIG_UNBLOCK
, &set
, NULL
);
274 if (se
->sa_flags
& SA_RESETHAND
) {
280 se
->handler(ev
, se
, i
, count
, NULL
, se
->private_data
);
281 if (se
->sa_flags
& SA_RESETHAND
) {
285 SIG_SEEN(sig_state
->signal_count
[i
], count
);
286 SIG_SEEN(sig_state
->got_signal
, count
);