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 35typedef struct { 36 uv_signal_t* handle; 37 int signum; 38} uv__signal_msg_t; 39 40RB_HEAD(uv__signal_tree_s, uv_signal_s); 41 42 43static int uv__signal_unlock(void); 44static int uv__signal_start(uv_signal_t* handle, 45 uv_signal_cb signal_cb, 46 int signum, 47 int oneshot); 48static void uv__signal_event(uv_loop_t* loop, uv__io_t* w, unsigned int events); 49static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2); 50static void uv__signal_stop(uv_signal_t* handle); 51static void uv__signal_unregister_handler(int signum); 52 53 54static uv_once_t uv__signal_global_init_guard = UV_ONCE_INIT; 55static struct uv__signal_tree_s uv__signal_tree = 56 RB_INITIALIZER(uv__signal_tree); 57static int uv__signal_lock_pipefd[2] = { -1, -1 }; 58 59RB_GENERATE_STATIC(uv__signal_tree_s, 60 uv_signal_s, tree_entry, 61 uv__signal_compare) 62 63static void uv__signal_global_reinit(void); 64 65static 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 80void 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 100static 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 111void uv__signal_global_once_init(void) { 112 uv_once(&uv__signal_global_init_guard, uv__signal_global_init); 113} 114 115 116static 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 128static 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 140static 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 156static 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 165static 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 183static 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, &uv__signal_tree, 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 224static 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 245static 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 261static int uv__signal_loop_once_init(uv_loop_t* loop) { 262 int err; 263 264 /* Return if already initialized. */ 265 if (loop->signal_pipefd[0] != -1) 266 return 0; 267 268 err = uv__make_pipe(loop->signal_pipefd, UV_NONBLOCK_PIPE); 269 if (err) 270 return err; 271 272 uv__io_init(&loop->signal_io_watcher, 273 uv__signal_event, 274 loop->signal_pipefd[0]); 275 uv__io_start(loop, &loop->signal_io_watcher, POLLIN); 276 277 return 0; 278} 279 280 281int uv__signal_loop_fork(uv_loop_t* loop) { 282 uv__io_stop(loop, &loop->signal_io_watcher, POLLIN); 283 uv__close(loop->signal_pipefd[0]); 284 uv__close(loop->signal_pipefd[1]); 285 loop->signal_pipefd[0] = -1; 286 loop->signal_pipefd[1] = -1; 287 return uv__signal_loop_once_init(loop); 288} 289 290 291void uv__signal_loop_cleanup(uv_loop_t* loop) { 292 QUEUE* q; 293 294 /* Stop all the signal watchers that are still attached to this loop. This 295 * ensures that the (shared) signal tree doesn't contain any invalid entries 296 * entries, and that signal handlers are removed when appropriate. 297 * It's safe to use QUEUE_FOREACH here because the handles and the handle 298 * queue are not modified by uv__signal_stop(). 299 */ 300 QUEUE_FOREACH(q, &loop->handle_queue) { 301 uv_handle_t* handle = QUEUE_DATA(q, uv_handle_t, handle_queue); 302 303 if (handle->type == UV_SIGNAL) 304 uv__signal_stop((uv_signal_t*) handle); 305 } 306 307 if (loop->signal_pipefd[0] != -1) { 308 uv__close(loop->signal_pipefd[0]); 309 loop->signal_pipefd[0] = -1; 310 } 311 312 if (loop->signal_pipefd[1] != -1) { 313 uv__close(loop->signal_pipefd[1]); 314 loop->signal_pipefd[1] = -1; 315 } 316} 317 318 319int uv_signal_init(uv_loop_t* loop, uv_signal_t* handle) { 320 int err; 321 322 err = uv__signal_loop_once_init(loop); 323 if (err) 324 return err; 325 326 uv__handle_init(loop, (uv_handle_t*) handle, UV_SIGNAL); 327 handle->signum = 0; 328 handle->caught_signals = 0; 329 handle->dispatched_signals = 0; 330 331 return 0; 332} 333 334 335void uv__signal_close(uv_signal_t* handle) { 336 uv__signal_stop(handle); 337} 338 339 340int uv_signal_start(uv_signal_t* handle, uv_signal_cb signal_cb, int signum) { 341 return uv__signal_start(handle, signal_cb, signum, 0); 342} 343 344 345int uv_signal_start_oneshot(uv_signal_t* handle, 346 uv_signal_cb signal_cb, 347 int signum) { 348 return uv__signal_start(handle, signal_cb, signum, 1); 349} 350 351 352static int uv__signal_start(uv_signal_t* handle, 353 uv_signal_cb signal_cb, 354 int signum, 355 int oneshot) { 356 sigset_t saved_sigmask; 357 int err; 358 uv_signal_t* first_handle; 359 360 assert(!uv__is_closing(handle)); 361 362 /* If the user supplies signum == 0, then return an error already. If the 363 * signum is otherwise invalid then uv__signal_register will find out 364 * eventually. 365 */ 366 if (signum == 0) 367 return UV_EINVAL; 368 369 /* Short circuit: if the signal watcher is already watching {signum} don't 370 * go through the process of deregistering and registering the handler. 371 * Additionally, this avoids pending signals getting lost in the small 372 * time frame that handle->signum == 0. 373 */ 374 if (signum == handle->signum) { 375 handle->signal_cb = signal_cb; 376 return 0; 377 } 378 379 /* If the signal handler was already active, stop it first. */ 380 if (handle->signum != 0) { 381 uv__signal_stop(handle); 382 } 383 384 uv__signal_block_and_lock(&saved_sigmask); 385 386 /* If at this point there are no active signal watchers for this signum (in 387 * any of the loops), it's time to try and register a handler for it here. 388 * Also in case there's only one-shot handlers and a regular handler comes in. 389 */ 390 first_handle = uv__signal_first_handle(signum); 391 if (first_handle == NULL || 392 (!oneshot && (first_handle->flags & UV_SIGNAL_ONE_SHOT))) { 393 err = uv__signal_register_handler(signum, oneshot); 394 if (err) { 395 /* Registering the signal handler failed. Must be an invalid signal. */ 396 uv__signal_unlock_and_unblock(&saved_sigmask); 397 return err; 398 } 399 } 400 401 handle->signum = signum; 402 if (oneshot) 403 handle->flags |= UV_SIGNAL_ONE_SHOT; 404 405 RB_INSERT(uv__signal_tree_s, &uv__signal_tree, handle); 406 407 uv__signal_unlock_and_unblock(&saved_sigmask); 408 409 handle->signal_cb = signal_cb; 410 uv__handle_start(handle); 411 412 return 0; 413} 414 415 416static void uv__signal_event(uv_loop_t* loop, 417 uv__io_t* w, 418 unsigned int events) { 419 uv__signal_msg_t* msg; 420 uv_signal_t* handle; 421 char buf[sizeof(uv__signal_msg_t) * 32]; 422 size_t bytes, end, i; 423 int r; 424 425 bytes = 0; 426 end = 0; 427 428 do { 429 r = read(loop->signal_pipefd[0], buf + bytes, sizeof(buf) - bytes); 430 431 if (r == -1 && errno == EINTR) 432 continue; 433 434 if (r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) { 435 /* If there are bytes in the buffer already (which really is extremely 436 * unlikely if possible at all) we can't exit the function here. We'll 437 * spin until more bytes are read instead. 438 */ 439 if (bytes > 0) 440 continue; 441 442 /* Otherwise, there was nothing there. */ 443 return; 444 } 445 446 /* Other errors really should never happen. */ 447 if (r == -1) 448 abort(); 449 450 bytes += r; 451 452 /* `end` is rounded down to a multiple of sizeof(uv__signal_msg_t). */ 453 end = (bytes / sizeof(uv__signal_msg_t)) * sizeof(uv__signal_msg_t); 454 455 for (i = 0; i < end; i += sizeof(uv__signal_msg_t)) { 456 msg = (uv__signal_msg_t*) (buf + i); 457 handle = msg->handle; 458 459 if (msg->signum == handle->signum) { 460 assert(!(handle->flags & UV_HANDLE_CLOSING)); 461 handle->signal_cb(handle, handle->signum); 462 } 463 464 handle->dispatched_signals++; 465 466 if (handle->flags & UV_SIGNAL_ONE_SHOT) 467 uv__signal_stop(handle); 468 } 469 470 bytes -= end; 471 472 /* If there are any "partial" messages left, move them to the start of the 473 * the buffer, and spin. This should not happen. 474 */ 475 if (bytes) { 476 memmove(buf, buf + end, bytes); 477 continue; 478 } 479 } while (end == sizeof buf); 480} 481 482 483static int uv__signal_compare(uv_signal_t* w1, uv_signal_t* w2) { 484 int f1; 485 int f2; 486 /* Compare signums first so all watchers with the same signnum end up 487 * adjacent. 488 */ 489 if (w1->signum < w2->signum) return -1; 490 if (w1->signum > w2->signum) return 1; 491 492 /* Handlers without UV_SIGNAL_ONE_SHOT set will come first, so if the first 493 * handler returned is a one-shot handler, the rest will be too. 494 */ 495 f1 = w1->flags & UV_SIGNAL_ONE_SHOT; 496 f2 = w2->flags & UV_SIGNAL_ONE_SHOT; 497 if (f1 < f2) return -1; 498 if (f1 > f2) return 1; 499 500 /* Sort by loop pointer, so we can easily look up the first item after 501 * { .signum = x, .loop = NULL }. 502 */ 503 if (w1->loop < w2->loop) return -1; 504 if (w1->loop > w2->loop) return 1; 505 506 if (w1 < w2) return -1; 507 if (w1 > w2) return 1; 508 509 return 0; 510} 511 512 513int uv_signal_stop(uv_signal_t* handle) { 514 assert(!uv__is_closing(handle)); 515 uv__signal_stop(handle); 516 return 0; 517} 518 519 520static void uv__signal_stop(uv_signal_t* handle) { 521 uv_signal_t* removed_handle; 522 sigset_t saved_sigmask; 523 uv_signal_t* first_handle; 524 int rem_oneshot; 525 int first_oneshot; 526 int ret; 527 528 /* If the watcher wasn't started, this is a no-op. */ 529 if (handle->signum == 0) 530 return; 531 532 uv__signal_block_and_lock(&saved_sigmask); 533 534 removed_handle = RB_REMOVE(uv__signal_tree_s, &uv__signal_tree, handle); 535 assert(removed_handle == handle); 536 (void) removed_handle; 537 538 /* Check if there are other active signal watchers observing this signal. If 539 * not, unregister the signal handler. 540 */ 541 first_handle = uv__signal_first_handle(handle->signum); 542 if (first_handle == NULL) { 543 uv__signal_unregister_handler(handle->signum); 544 } else { 545 rem_oneshot = handle->flags & UV_SIGNAL_ONE_SHOT; 546 first_oneshot = first_handle->flags & UV_SIGNAL_ONE_SHOT; 547 if (first_oneshot && !rem_oneshot) { 548 ret = uv__signal_register_handler(handle->signum, 1); 549 assert(ret == 0); 550 (void)ret; 551 } 552 } 553 554 uv__signal_unlock_and_unblock(&saved_sigmask); 555 556 handle->signum = 0; 557 uv__handle_stop(handle); 558} 559