Mercurial

comparison third_party/libuv/src/unix/signal.c @ 160:948de3f54cea

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