1fbb2e0a3Schristos /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
2fbb2e0a3Schristos * Permission is hereby granted, free of charge, to any person obtaining a copy
3fbb2e0a3Schristos * of this software and associated documentation files (the "Software"), to
4fbb2e0a3Schristos * deal in the Software without restriction, including without limitation the
5fbb2e0a3Schristos * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
6fbb2e0a3Schristos * sell copies of the Software, and to permit persons to whom the Software is
7fbb2e0a3Schristos * furnished to do so, subject to the following conditions:
8fbb2e0a3Schristos *
9fbb2e0a3Schristos * The above copyright notice and this permission notice shall be included in
10fbb2e0a3Schristos * all copies or substantial portions of the Software.
11fbb2e0a3Schristos *
12fbb2e0a3Schristos * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13fbb2e0a3Schristos * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14fbb2e0a3Schristos * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
15fbb2e0a3Schristos * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
16fbb2e0a3Schristos * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
17fbb2e0a3Schristos * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
18fbb2e0a3Schristos * IN THE SOFTWARE.
19fbb2e0a3Schristos */
20fbb2e0a3Schristos
21fbb2e0a3Schristos #include "uv.h"
22fbb2e0a3Schristos #include "internal.h"
23fbb2e0a3Schristos
24fbb2e0a3Schristos #include <assert.h>
25fbb2e0a3Schristos #include <errno.h>
26fbb2e0a3Schristos #include <signal.h>
27fbb2e0a3Schristos #include <stdlib.h>
28fbb2e0a3Schristos #include <string.h>
29fbb2e0a3Schristos #include <unistd.h>
30fbb2e0a3Schristos
31fbb2e0a3Schristos #ifndef SA_RESTART
32fbb2e0a3Schristos # define SA_RESTART 0
33fbb2e0a3Schristos #endif
34fbb2e0a3Schristos
35fbb2e0a3Schristos typedef struct {
36fbb2e0a3Schristos uv_signal_t* handle;
37fbb2e0a3Schristos int signum;
38fbb2e0a3Schristos } uv__signal_msg_t;
39fbb2e0a3Schristos
40fbb2e0a3Schristos RB_HEAD(uv__signal_tree_s, uv_signal_s);
41fbb2e0a3Schristos
42fbb2e0a3Schristos
43fbb2e0a3Schristos static int uv__signal_unlock(void);
44fbb2e0a3Schristos static int uv__signal_start(uv_signal_t* handle,
45fbb2e0a3Schristos uv_signal_cb signal_cb,
46fbb2e0a3Schristos int signum,
47fbb2e0a3Schristos int oneshot);
48fbb2e0a3Schristos static void uv__signal_event(uv_loop_t* loop, uv__io_t* w, unsigned int events);
49fbb2e0a3Schristos static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2);
50fbb2e0a3Schristos static void uv__signal_stop(uv_signal_t* handle);
51fbb2e0a3Schristos static void uv__signal_unregister_handler(int signum);
52fbb2e0a3Schristos
53fbb2e0a3Schristos
54fbb2e0a3Schristos static uv_once_t uv__signal_global_init_guard = UV_ONCE_INIT;
55fbb2e0a3Schristos static struct uv__signal_tree_s uv__signal_tree =
56fbb2e0a3Schristos RB_INITIALIZER(uv__signal_tree);
57fbb2e0a3Schristos static int uv__signal_lock_pipefd[2] = { -1, -1 };
58fbb2e0a3Schristos
59fbb2e0a3Schristos RB_GENERATE_STATIC(uv__signal_tree_s,
60fbb2e0a3Schristos uv_signal_s, tree_entry,
61fbb2e0a3Schristos uv__signal_compare)
62fbb2e0a3Schristos
63fbb2e0a3Schristos static void uv__signal_global_reinit(void);
64fbb2e0a3Schristos
uv__signal_global_init(void)65fbb2e0a3Schristos static void uv__signal_global_init(void) {
66fbb2e0a3Schristos if (uv__signal_lock_pipefd[0] == -1)
67fbb2e0a3Schristos /* pthread_atfork can register before and after handlers, one
68fbb2e0a3Schristos * for each child. This only registers one for the child. That
69fbb2e0a3Schristos * state is both persistent and cumulative, so if we keep doing
70fbb2e0a3Schristos * it the handler functions will be called multiple times. Thus
71fbb2e0a3Schristos * we only want to do it once.
72fbb2e0a3Schristos */
73fbb2e0a3Schristos if (pthread_atfork(NULL, NULL, &uv__signal_global_reinit))
74fbb2e0a3Schristos abort();
75fbb2e0a3Schristos
76fbb2e0a3Schristos uv__signal_global_reinit();
77fbb2e0a3Schristos }
78fbb2e0a3Schristos
79fbb2e0a3Schristos
uv__signal_cleanup(void)80fbb2e0a3Schristos void uv__signal_cleanup(void) {
81fbb2e0a3Schristos /* We can only use signal-safe functions here.
82fbb2e0a3Schristos * That includes read/write and close, fortunately.
83fbb2e0a3Schristos * We do all of this directly here instead of resetting
84fbb2e0a3Schristos * uv__signal_global_init_guard because
85fbb2e0a3Schristos * uv__signal_global_once_init is only called from uv_loop_init
86fbb2e0a3Schristos * and this needs to function in existing loops.
87fbb2e0a3Schristos */
88fbb2e0a3Schristos if (uv__signal_lock_pipefd[0] != -1) {
89fbb2e0a3Schristos uv__close(uv__signal_lock_pipefd[0]);
90fbb2e0a3Schristos uv__signal_lock_pipefd[0] = -1;
91fbb2e0a3Schristos }
92fbb2e0a3Schristos
93fbb2e0a3Schristos if (uv__signal_lock_pipefd[1] != -1) {
94fbb2e0a3Schristos uv__close(uv__signal_lock_pipefd[1]);
95fbb2e0a3Schristos uv__signal_lock_pipefd[1] = -1;
96fbb2e0a3Schristos }
97fbb2e0a3Schristos }
98fbb2e0a3Schristos
99fbb2e0a3Schristos
uv__signal_global_reinit(void)100fbb2e0a3Schristos static void uv__signal_global_reinit(void) {
101fbb2e0a3Schristos uv__signal_cleanup();
102fbb2e0a3Schristos
103fbb2e0a3Schristos if (uv__make_pipe(uv__signal_lock_pipefd, 0))
104fbb2e0a3Schristos abort();
105fbb2e0a3Schristos
106fbb2e0a3Schristos if (uv__signal_unlock())
107fbb2e0a3Schristos abort();
108fbb2e0a3Schristos }
109fbb2e0a3Schristos
110fbb2e0a3Schristos
uv__signal_global_once_init(void)111fbb2e0a3Schristos void uv__signal_global_once_init(void) {
112fbb2e0a3Schristos uv_once(&uv__signal_global_init_guard, uv__signal_global_init);
113fbb2e0a3Schristos }
114fbb2e0a3Schristos
115fbb2e0a3Schristos
uv__signal_lock(void)116fbb2e0a3Schristos static int uv__signal_lock(void) {
117fbb2e0a3Schristos int r;
118fbb2e0a3Schristos char data;
119fbb2e0a3Schristos
120fbb2e0a3Schristos do {
121fbb2e0a3Schristos r = read(uv__signal_lock_pipefd[0], &data, sizeof data);
122fbb2e0a3Schristos } while (r < 0 && errno == EINTR);
123fbb2e0a3Schristos
124fbb2e0a3Schristos return (r < 0) ? -1 : 0;
125fbb2e0a3Schristos }
126fbb2e0a3Schristos
127fbb2e0a3Schristos
uv__signal_unlock(void)128fbb2e0a3Schristos static int uv__signal_unlock(void) {
129fbb2e0a3Schristos int r;
130fbb2e0a3Schristos char data = 42;
131fbb2e0a3Schristos
132fbb2e0a3Schristos do {
133fbb2e0a3Schristos r = write(uv__signal_lock_pipefd[1], &data, sizeof data);
134fbb2e0a3Schristos } while (r < 0 && errno == EINTR);
135fbb2e0a3Schristos
136fbb2e0a3Schristos return (r < 0) ? -1 : 0;
137fbb2e0a3Schristos }
138fbb2e0a3Schristos
139fbb2e0a3Schristos
uv__signal_block_and_lock(sigset_t * saved_sigmask)140fbb2e0a3Schristos static void uv__signal_block_and_lock(sigset_t* saved_sigmask) {
141fbb2e0a3Schristos sigset_t new_mask;
142fbb2e0a3Schristos
143fbb2e0a3Schristos if (sigfillset(&new_mask))
144fbb2e0a3Schristos abort();
145fbb2e0a3Schristos
146*b29f2fbfSchristos /* to shut up valgrind */
147*b29f2fbfSchristos sigemptyset(saved_sigmask);
148fbb2e0a3Schristos if (pthread_sigmask(SIG_SETMASK, &new_mask, saved_sigmask))
149fbb2e0a3Schristos abort();
150fbb2e0a3Schristos
151fbb2e0a3Schristos if (uv__signal_lock())
152fbb2e0a3Schristos abort();
153fbb2e0a3Schristos }
154fbb2e0a3Schristos
155fbb2e0a3Schristos
uv__signal_unlock_and_unblock(sigset_t * saved_sigmask)156fbb2e0a3Schristos static void uv__signal_unlock_and_unblock(sigset_t* saved_sigmask) {
157fbb2e0a3Schristos if (uv__signal_unlock())
158fbb2e0a3Schristos abort();
159fbb2e0a3Schristos
160fbb2e0a3Schristos if (pthread_sigmask(SIG_SETMASK, saved_sigmask, NULL))
161fbb2e0a3Schristos abort();
162fbb2e0a3Schristos }
163fbb2e0a3Schristos
164fbb2e0a3Schristos
uv__signal_first_handle(int signum)165fbb2e0a3Schristos static uv_signal_t* uv__signal_first_handle(int signum) {
166fbb2e0a3Schristos /* This function must be called with the signal lock held. */
167fbb2e0a3Schristos uv_signal_t lookup;
168fbb2e0a3Schristos uv_signal_t* handle;
169fbb2e0a3Schristos
170fbb2e0a3Schristos lookup.signum = signum;
171fbb2e0a3Schristos lookup.flags = 0;
172fbb2e0a3Schristos lookup.loop = NULL;
173fbb2e0a3Schristos
174fbb2e0a3Schristos handle = RB_NFIND(uv__signal_tree_s, &uv__signal_tree, &lookup);
175fbb2e0a3Schristos
176fbb2e0a3Schristos if (handle != NULL && handle->signum == signum)
177fbb2e0a3Schristos return handle;
178fbb2e0a3Schristos
179fbb2e0a3Schristos return NULL;
180fbb2e0a3Schristos }
181fbb2e0a3Schristos
182fbb2e0a3Schristos
uv__signal_handler(int signum)183fbb2e0a3Schristos static void uv__signal_handler(int signum) {
184fbb2e0a3Schristos uv__signal_msg_t msg;
185fbb2e0a3Schristos uv_signal_t* handle;
186fbb2e0a3Schristos int saved_errno;
187fbb2e0a3Schristos
188fbb2e0a3Schristos saved_errno = errno;
189fbb2e0a3Schristos memset(&msg, 0, sizeof msg);
190fbb2e0a3Schristos
191fbb2e0a3Schristos if (uv__signal_lock()) {
192fbb2e0a3Schristos errno = saved_errno;
193fbb2e0a3Schristos return;
194fbb2e0a3Schristos }
195fbb2e0a3Schristos
196fbb2e0a3Schristos for (handle = uv__signal_first_handle(signum);
197fbb2e0a3Schristos handle != NULL && handle->signum == signum;
198fbb2e0a3Schristos handle = RB_NEXT(uv__signal_tree_s, &uv__signal_tree, handle)) {
199fbb2e0a3Schristos int r;
200fbb2e0a3Schristos
201fbb2e0a3Schristos msg.signum = signum;
202fbb2e0a3Schristos msg.handle = handle;
203fbb2e0a3Schristos
204fbb2e0a3Schristos /* write() should be atomic for small data chunks, so the entire message
205fbb2e0a3Schristos * should be written at once. In theory the pipe could become full, in
206fbb2e0a3Schristos * which case the user is out of luck.
207fbb2e0a3Schristos */
208fbb2e0a3Schristos do {
209fbb2e0a3Schristos r = write(handle->loop->signal_pipefd[1], &msg, sizeof msg);
210fbb2e0a3Schristos } while (r == -1 && errno == EINTR);
211fbb2e0a3Schristos
212fbb2e0a3Schristos assert(r == sizeof msg ||
213fbb2e0a3Schristos (r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)));
214fbb2e0a3Schristos
215fbb2e0a3Schristos if (r != -1)
216fbb2e0a3Schristos handle->caught_signals++;
217fbb2e0a3Schristos }
218fbb2e0a3Schristos
219fbb2e0a3Schristos uv__signal_unlock();
220fbb2e0a3Schristos errno = saved_errno;
221fbb2e0a3Schristos }
222fbb2e0a3Schristos
223fbb2e0a3Schristos
uv__signal_register_handler(int signum,int oneshot)224fbb2e0a3Schristos static int uv__signal_register_handler(int signum, int oneshot) {
225fbb2e0a3Schristos /* When this function is called, the signal lock must be held. */
226fbb2e0a3Schristos struct sigaction sa;
227fbb2e0a3Schristos
228fbb2e0a3Schristos /* XXX use a separate signal stack? */
229fbb2e0a3Schristos memset(&sa, 0, sizeof(sa));
230fbb2e0a3Schristos if (sigfillset(&sa.sa_mask))
231fbb2e0a3Schristos abort();
232fbb2e0a3Schristos sa.sa_handler = uv__signal_handler;
233fbb2e0a3Schristos sa.sa_flags = SA_RESTART;
234fbb2e0a3Schristos if (oneshot)
235fbb2e0a3Schristos sa.sa_flags |= SA_RESETHAND;
236fbb2e0a3Schristos
237fbb2e0a3Schristos /* XXX save old action so we can restore it later on? */
238fbb2e0a3Schristos if (sigaction(signum, &sa, NULL))
239fbb2e0a3Schristos return UV__ERR(errno);
240fbb2e0a3Schristos
241fbb2e0a3Schristos return 0;
242fbb2e0a3Schristos }
243fbb2e0a3Schristos
244fbb2e0a3Schristos
uv__signal_unregister_handler(int signum)245fbb2e0a3Schristos static void uv__signal_unregister_handler(int signum) {
246fbb2e0a3Schristos /* When this function is called, the signal lock must be held. */
247fbb2e0a3Schristos struct sigaction sa;
248fbb2e0a3Schristos
249fbb2e0a3Schristos memset(&sa, 0, sizeof(sa));
250fbb2e0a3Schristos sa.sa_handler = SIG_DFL;
251fbb2e0a3Schristos
252fbb2e0a3Schristos /* sigaction can only fail with EINVAL or EFAULT; an attempt to deregister a
253fbb2e0a3Schristos * signal implies that it was successfully registered earlier, so EINVAL
254fbb2e0a3Schristos * should never happen.
255fbb2e0a3Schristos */
256fbb2e0a3Schristos if (sigaction(signum, &sa, NULL))
257fbb2e0a3Schristos abort();
258fbb2e0a3Schristos }
259fbb2e0a3Schristos
260fbb2e0a3Schristos
uv__signal_loop_once_init(uv_loop_t * loop)261fbb2e0a3Schristos static int uv__signal_loop_once_init(uv_loop_t* loop) {
262fbb2e0a3Schristos int err;
263fbb2e0a3Schristos
264fbb2e0a3Schristos /* Return if already initialized. */
265fbb2e0a3Schristos if (loop->signal_pipefd[0] != -1)
266fbb2e0a3Schristos return 0;
267fbb2e0a3Schristos
268*b29f2fbfSchristos err = uv__make_pipe(loop->signal_pipefd, UV_NONBLOCK_PIPE);
269fbb2e0a3Schristos if (err)
270fbb2e0a3Schristos return err;
271fbb2e0a3Schristos
272fbb2e0a3Schristos uv__io_init(&loop->signal_io_watcher,
273fbb2e0a3Schristos uv__signal_event,
274fbb2e0a3Schristos loop->signal_pipefd[0]);
275fbb2e0a3Schristos uv__io_start(loop, &loop->signal_io_watcher, POLLIN);
276fbb2e0a3Schristos
277fbb2e0a3Schristos return 0;
278fbb2e0a3Schristos }
279fbb2e0a3Schristos
280fbb2e0a3Schristos
uv__signal_loop_fork(uv_loop_t * loop)281fbb2e0a3Schristos int uv__signal_loop_fork(uv_loop_t* loop) {
282fbb2e0a3Schristos uv__io_stop(loop, &loop->signal_io_watcher, POLLIN);
283fbb2e0a3Schristos uv__close(loop->signal_pipefd[0]);
284fbb2e0a3Schristos uv__close(loop->signal_pipefd[1]);
285fbb2e0a3Schristos loop->signal_pipefd[0] = -1;
286fbb2e0a3Schristos loop->signal_pipefd[1] = -1;
287fbb2e0a3Schristos return uv__signal_loop_once_init(loop);
288fbb2e0a3Schristos }
289fbb2e0a3Schristos
290fbb2e0a3Schristos
uv__signal_loop_cleanup(uv_loop_t * loop)291fbb2e0a3Schristos void uv__signal_loop_cleanup(uv_loop_t* loop) {
292fbb2e0a3Schristos QUEUE* q;
293fbb2e0a3Schristos
294fbb2e0a3Schristos /* Stop all the signal watchers that are still attached to this loop. This
295fbb2e0a3Schristos * ensures that the (shared) signal tree doesn't contain any invalid entries
296fbb2e0a3Schristos * entries, and that signal handlers are removed when appropriate.
297fbb2e0a3Schristos * It's safe to use QUEUE_FOREACH here because the handles and the handle
298fbb2e0a3Schristos * queue are not modified by uv__signal_stop().
299fbb2e0a3Schristos */
300fbb2e0a3Schristos QUEUE_FOREACH(q, &loop->handle_queue) {
301fbb2e0a3Schristos uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue);
302fbb2e0a3Schristos
303fbb2e0a3Schristos if (handle->type == UV_SIGNAL)
304fbb2e0a3Schristos uv__signal_stop((uv_signal_t*) handle);
305fbb2e0a3Schristos }
306fbb2e0a3Schristos
307fbb2e0a3Schristos if (loop->signal_pipefd[0] != -1) {
308fbb2e0a3Schristos uv__close(loop->signal_pipefd[0]);
309fbb2e0a3Schristos loop->signal_pipefd[0] = -1;
310fbb2e0a3Schristos }
311fbb2e0a3Schristos
312fbb2e0a3Schristos if (loop->signal_pipefd[1] != -1) {
313fbb2e0a3Schristos uv__close(loop->signal_pipefd[1]);
314fbb2e0a3Schristos loop->signal_pipefd[1] = -1;
315fbb2e0a3Schristos }
316fbb2e0a3Schristos }
317fbb2e0a3Schristos
318fbb2e0a3Schristos
uv_signal_init(uv_loop_t * loop,uv_signal_t * handle)319fbb2e0a3Schristos int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) {
320fbb2e0a3Schristos int err;
321fbb2e0a3Schristos
322fbb2e0a3Schristos err = uv__signal_loop_once_init(loop);
323fbb2e0a3Schristos if (err)
324fbb2e0a3Schristos return err;
325fbb2e0a3Schristos
326fbb2e0a3Schristos uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL);
327fbb2e0a3Schristos handle->signum = 0;
328fbb2e0a3Schristos handle->caught_signals = 0;
329fbb2e0a3Schristos handle->dispatched_signals = 0;
330fbb2e0a3Schristos
331fbb2e0a3Schristos return 0;
332fbb2e0a3Schristos }
333fbb2e0a3Schristos
334fbb2e0a3Schristos
uv__signal_close(uv_signal_t * handle)335fbb2e0a3Schristos void uv__signal_close(uv_signal_t* handle) {
336fbb2e0a3Schristos uv__signal_stop(handle);
337fbb2e0a3Schristos }
338fbb2e0a3Schristos
339fbb2e0a3Schristos
uv_signal_start(uv_signal_t * handle,uv_signal_cb signal_cb,int signum)340fbb2e0a3Schristos int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) {
341fbb2e0a3Schristos return uv__signal_start(handle, signal_cb, signum, 0);
342fbb2e0a3Schristos }
343fbb2e0a3Schristos
344fbb2e0a3Schristos
uv_signal_start_oneshot(uv_signal_t * handle,uv_signal_cb signal_cb,int signum)345fbb2e0a3Schristos int uv_signal_start_oneshot(uv_signal_t* handle,
346fbb2e0a3Schristos uv_signal_cb signal_cb,
347fbb2e0a3Schristos int signum) {
348fbb2e0a3Schristos return uv__signal_start(handle, signal_cb, signum, 1);
349fbb2e0a3Schristos }
350fbb2e0a3Schristos
351fbb2e0a3Schristos
uv__signal_start(uv_signal_t * handle,uv_signal_cb signal_cb,int signum,int oneshot)352fbb2e0a3Schristos static int uv__signal_start(uv_signal_t* handle,
353fbb2e0a3Schristos uv_signal_cb signal_cb,
354fbb2e0a3Schristos int signum,
355fbb2e0a3Schristos int oneshot) {
356fbb2e0a3Schristos sigset_t saved_sigmask;
357fbb2e0a3Schristos int err;
358fbb2e0a3Schristos uv_signal_t* first_handle;
359fbb2e0a3Schristos
360fbb2e0a3Schristos assert(!uv__is_closing(handle));
361fbb2e0a3Schristos
362fbb2e0a3Schristos /* If the user supplies signum == 0, then return an error already. If the
363fbb2e0a3Schristos * signum is otherwise invalid then uv__signal_register will find out
364fbb2e0a3Schristos * eventually.
365fbb2e0a3Schristos */
366fbb2e0a3Schristos if (signum == 0)
367fbb2e0a3Schristos return UV_EINVAL;
368fbb2e0a3Schristos
369fbb2e0a3Schristos /* Short circuit: if the signal watcher is already watching {signum} don't
370fbb2e0a3Schristos * go through the process of deregistering and registering the handler.
371fbb2e0a3Schristos * Additionally, this avoids pending signals getting lost in the small
372fbb2e0a3Schristos * time frame that handle->signum == 0.
373fbb2e0a3Schristos */
374fbb2e0a3Schristos if (signum == handle->signum) {
375fbb2e0a3Schristos handle->signal_cb = signal_cb;
376fbb2e0a3Schristos return 0;
377fbb2e0a3Schristos }
378fbb2e0a3Schristos
379fbb2e0a3Schristos /* If the signal handler was already active, stop it first. */
380fbb2e0a3Schristos if (handle->signum != 0) {
381fbb2e0a3Schristos uv__signal_stop(handle);
382fbb2e0a3Schristos }
383fbb2e0a3Schristos
384fbb2e0a3Schristos uv__signal_block_and_lock(&saved_sigmask);
385fbb2e0a3Schristos
386fbb2e0a3Schristos /* If at this point there are no active signal watchers for this signum (in
387fbb2e0a3Schristos * any of the loops), it's time to try and register a handler for it here.
388fbb2e0a3Schristos * Also in case there's only one-shot handlers and a regular handler comes in.
389fbb2e0a3Schristos */
390fbb2e0a3Schristos first_handle = uv__signal_first_handle(signum);
391fbb2e0a3Schristos if (first_handle == NULL ||
392fbb2e0a3Schristos (!oneshot && (first_handle->flags & UV_SIGNAL_ONE_SHOT))) {
393fbb2e0a3Schristos err = uv__signal_register_handler(signum, oneshot);
394fbb2e0a3Schristos if (err) {
395fbb2e0a3Schristos /* Registering the signal handler failed. Must be an invalid signal. */
396fbb2e0a3Schristos uv__signal_unlock_and_unblock(&saved_sigmask);
397fbb2e0a3Schristos return err;
398fbb2e0a3Schristos }
399fbb2e0a3Schristos }
400fbb2e0a3Schristos
401fbb2e0a3Schristos handle->signum = signum;
402fbb2e0a3Schristos if (oneshot)
403fbb2e0a3Schristos handle->flags |= UV_SIGNAL_ONE_SHOT;
404fbb2e0a3Schristos
405fbb2e0a3Schristos RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle);
406fbb2e0a3Schristos
407fbb2e0a3Schristos uv__signal_unlock_and_unblock(&saved_sigmask);
408fbb2e0a3Schristos
409fbb2e0a3Schristos handle->signal_cb = signal_cb;
410fbb2e0a3Schristos uv__handle_start(handle);
411fbb2e0a3Schristos
412fbb2e0a3Schristos return 0;
413fbb2e0a3Schristos }
414fbb2e0a3Schristos
415fbb2e0a3Schristos
uv__signal_event(uv_loop_t * loop,uv__io_t * w,unsigned int events)416fbb2e0a3Schristos static void uv__signal_event(uv_loop_t* loop,
417fbb2e0a3Schristos uv__io_t* w,
418fbb2e0a3Schristos unsigned int events) {
419fbb2e0a3Schristos uv__signal_msg_t* msg;
420fbb2e0a3Schristos uv_signal_t* handle;
421fbb2e0a3Schristos char buf[sizeof(uv__signal_msg_t) * 32];
422fbb2e0a3Schristos size_t bytes, end, i;
423fbb2e0a3Schristos int r;
424fbb2e0a3Schristos
425fbb2e0a3Schristos bytes = 0;
426fbb2e0a3Schristos end = 0;
427fbb2e0a3Schristos
428fbb2e0a3Schristos do {
429fbb2e0a3Schristos r = read(loop->signal_pipefd[0], buf + bytes, sizeof(buf) - bytes);
430fbb2e0a3Schristos
431fbb2e0a3Schristos if (r == -1 && errno == EINTR)
432fbb2e0a3Schristos continue;
433fbb2e0a3Schristos
434fbb2e0a3Schristos if (r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
435fbb2e0a3Schristos /* If there are bytes in the buffer already (which really is extremely
436fbb2e0a3Schristos * unlikely if possible at all) we can't exit the function here. We'll
437fbb2e0a3Schristos * spin until more bytes are read instead.
438fbb2e0a3Schristos */
439fbb2e0a3Schristos if (bytes > 0)
440fbb2e0a3Schristos continue;
441fbb2e0a3Schristos
442fbb2e0a3Schristos /* Otherwise, there was nothing there. */
443fbb2e0a3Schristos return;
444fbb2e0a3Schristos }
445fbb2e0a3Schristos
446fbb2e0a3Schristos /* Other errors really should never happen. */
447fbb2e0a3Schristos if (r == -1)
448fbb2e0a3Schristos abort();
449fbb2e0a3Schristos
450fbb2e0a3Schristos bytes += r;
451fbb2e0a3Schristos
452fbb2e0a3Schristos /* `end` is rounded down to a multiple of sizeof(uv__signal_msg_t). */
453fbb2e0a3Schristos end = (bytes / sizeof(uv__signal_msg_t)) * sizeof(uv__signal_msg_t);
454fbb2e0a3Schristos
455fbb2e0a3Schristos for (i = 0; i < end; i += sizeof(uv__signal_msg_t)) {
456fbb2e0a3Schristos msg = (uv__signal_msg_t*) (buf + i);
457fbb2e0a3Schristos handle = msg->handle;
458fbb2e0a3Schristos
459fbb2e0a3Schristos if (msg->signum == handle->signum) {
460fbb2e0a3Schristos assert(!(handle->flags & UV_HANDLE_CLOSING));
461fbb2e0a3Schristos handle->signal_cb(handle, handle->signum);
462fbb2e0a3Schristos }
463fbb2e0a3Schristos
464fbb2e0a3Schristos handle->dispatched_signals++;
465fbb2e0a3Schristos
466fbb2e0a3Schristos if (handle->flags & UV_SIGNAL_ONE_SHOT)
467fbb2e0a3Schristos uv__signal_stop(handle);
468fbb2e0a3Schristos }
469fbb2e0a3Schristos
470fbb2e0a3Schristos bytes -= end;
471fbb2e0a3Schristos
472fbb2e0a3Schristos /* If there are any "partial" messages left, move them to the start of the
473fbb2e0a3Schristos * the buffer, and spin. This should not happen.
474fbb2e0a3Schristos */
475fbb2e0a3Schristos if (bytes) {
476fbb2e0a3Schristos memmove(buf, buf + end, bytes);
477fbb2e0a3Schristos continue;
478fbb2e0a3Schristos }
479fbb2e0a3Schristos } while (end == sizeof buf);
480fbb2e0a3Schristos }
481fbb2e0a3Schristos
482fbb2e0a3Schristos
uv__signal_compare(uv_signal_t * w1,uv_signal_t * w2)483fbb2e0a3Schristos static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) {
484fbb2e0a3Schristos int f1;
485fbb2e0a3Schristos int f2;
486fbb2e0a3Schristos /* Compare signums first so all watchers with the same signnum end up
487fbb2e0a3Schristos * adjacent.
488fbb2e0a3Schristos */
489fbb2e0a3Schristos if (w1->signum < w2->signum) return -1;
490fbb2e0a3Schristos if (w1->signum > w2->signum) return 1;
491fbb2e0a3Schristos
492fbb2e0a3Schristos /* Handlers without UV_SIGNAL_ONE_SHOT set will come first, so if the first
493fbb2e0a3Schristos * handler returned is a one-shot handler, the rest will be too.
494fbb2e0a3Schristos */
495fbb2e0a3Schristos f1 = w1->flags & UV_SIGNAL_ONE_SHOT;
496fbb2e0a3Schristos f2 = w2->flags & UV_SIGNAL_ONE_SHOT;
497fbb2e0a3Schristos if (f1 < f2) return -1;
498fbb2e0a3Schristos if (f1 > f2) return 1;
499fbb2e0a3Schristos
500fbb2e0a3Schristos /* Sort by loop pointer, so we can easily look up the first item after
501fbb2e0a3Schristos * { .signum = x, .loop = NULL }.
502fbb2e0a3Schristos */
503fbb2e0a3Schristos if (w1->loop < w2->loop) return -1;
504fbb2e0a3Schristos if (w1->loop > w2->loop) return 1;
505fbb2e0a3Schristos
506fbb2e0a3Schristos if (w1 < w2) return -1;
507fbb2e0a3Schristos if (w1 > w2) return 1;
508fbb2e0a3Schristos
509fbb2e0a3Schristos return 0;
510fbb2e0a3Schristos }
511fbb2e0a3Schristos
512fbb2e0a3Schristos
uv_signal_stop(uv_signal_t * handle)513fbb2e0a3Schristos int uv_signal_stop(uv_signal_t* handle) {
514fbb2e0a3Schristos assert(!uv__is_closing(handle));
515fbb2e0a3Schristos uv__signal_stop(handle);
516fbb2e0a3Schristos return 0;
517fbb2e0a3Schristos }
518fbb2e0a3Schristos
519fbb2e0a3Schristos
uv__signal_stop(uv_signal_t * handle)520fbb2e0a3Schristos static void uv__signal_stop(uv_signal_t* handle) {
521fbb2e0a3Schristos uv_signal_t* removed_handle;
522fbb2e0a3Schristos sigset_t saved_sigmask;
523fbb2e0a3Schristos uv_signal_t* first_handle;
524fbb2e0a3Schristos int rem_oneshot;
525fbb2e0a3Schristos int first_oneshot;
526fbb2e0a3Schristos int ret;
527fbb2e0a3Schristos
528fbb2e0a3Schristos /* If the watcher wasn't started, this is a no-op. */
529fbb2e0a3Schristos if (handle->signum == 0)
530fbb2e0a3Schristos return;
531fbb2e0a3Schristos
532fbb2e0a3Schristos uv__signal_block_and_lock(&saved_sigmask);
533fbb2e0a3Schristos
534fbb2e0a3Schristos removed_handle = RB_REMOVE(uv__signal_tree_s, &uv__signal_tree, handle);
535fbb2e0a3Schristos assert(removed_handle == handle);
536fbb2e0a3Schristos (void) removed_handle;
537fbb2e0a3Schristos
538fbb2e0a3Schristos /* Check if there are other active signal watchers observing this signal. If
539fbb2e0a3Schristos * not, unregister the signal handler.
540fbb2e0a3Schristos */
541fbb2e0a3Schristos first_handle = uv__signal_first_handle(handle->signum);
542fbb2e0a3Schristos if (first_handle == NULL) {
543fbb2e0a3Schristos uv__signal_unregister_handler(handle->signum);
544fbb2e0a3Schristos } else {
545fbb2e0a3Schristos rem_oneshot = handle->flags & UV_SIGNAL_ONE_SHOT;
546fbb2e0a3Schristos first_oneshot = first_handle->flags & UV_SIGNAL_ONE_SHOT;
547fbb2e0a3Schristos if (first_oneshot && !rem_oneshot) {
548fbb2e0a3Schristos ret = uv__signal_register_handler(handle->signum, 1);
549fbb2e0a3Schristos assert(ret == 0);
550fbb2e0a3Schristos (void)ret;
551fbb2e0a3Schristos }
552fbb2e0a3Schristos }
553fbb2e0a3Schristos
554fbb2e0a3Schristos uv__signal_unlock_and_unblock(&saved_sigmask);
555fbb2e0a3Schristos
556fbb2e0a3Schristos handle->signum = 0;
557fbb2e0a3Schristos uv__handle_stop(handle);
558fbb2e0a3Schristos }
559