deps/uv/src/unix/core.c

   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 <stddef.h> /* NULL */
  25 #include <stdio.h> /* printf */
  26 #include <stdlib.h>
  27 #include <string.h> /* strerror */
  28 #include <errno.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <fcntl.h>
  34 #include <sys/socket.h>
  35 #include <sys/un.h>
  36 #include <netinet/in.h>
  37 #include <arpa/inet.h>
  38 #include <limits.h> /* INT_MAX, PATH_MAX */
  39 #include <sys/uio.h> /* writev */
  40
  41 #ifdef __linux__
  42 # include <sys/ioctl.h>
  43 #endif
  44
  45 #ifdef __sun
  46 # include <sys/types.h>
  47 # include <sys/wait.h>
  48 #endif
  49
  50 #ifdef __APPLE__
  51 # include <mach-o/dyld.h> /* _NSGetExecutablePath */
  52 # include <sys/filio.h>
  53 # include <sys/ioctl.h>
  54 #endif
  55
  56 #ifdef __FreeBSD__
  57 # include <sys/sysctl.h>
  58 # include <sys/filio.h>
  59 # include <sys/ioctl.h>
  60 # include <sys/wait.h>
  61 #endif
  62
  63 static void uv__run_pending(uv_loop_t* loop);
  64
  65 static uv_loop_t default_loop_struct;
  66 static uv_loop_t* default_loop_ptr;
  67
  68 /* Verify that uv_buf_t is ABI-compatible with struct iovec. */
  69 STATIC_ASSERT(sizeof(uv_buf_t) == sizeof(struct iovec));
  70 STATIC_ASSERT(sizeof(&((uv_buf_t*) 0)->base) ==
  71               sizeof(((struct iovec*) 0)->iov_base));
  72 STATIC_ASSERT(sizeof(&((uv_buf_t*) 0)->len) ==
  73               sizeof(((struct iovec*) 0)->iov_len));
  74 STATIC_ASSERT(offsetof(uv_buf_t, base) == offsetof(struct iovec, iov_base));
  75 STATIC_ASSERT(offsetof(uv_buf_t, len) == offsetof(struct iovec, iov_len));
  76
  77
  78 uint64_t uv_hrtime(void) {
  79   return uv__hrtime();
  80 }
  81
  82
  83 void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
  84   assert(!(handle->flags & (UV_CLOSING | UV_CLOSED)));
  85
  86   handle->flags |= UV_CLOSING;
  87   handle->close_cb = close_cb;
  88
  89   switch (handle->type) {
  90   case UV_NAMED_PIPE:
  91     uv__pipe_close((uv_pipe_t*)handle);
  92     break;
  93
  94   case UV_TTY:
  95     uv__stream_close((uv_stream_t*)handle);
  96     break;
  97
  98   case UV_TCP:
  99     uv__tcp_close((uv_tcp_t*)handle);
 100     break;
 101
 102   case UV_UDP:
 103     uv__udp_close((uv_udp_t*)handle);
 104     break;
 105
 106   case UV_PREPARE:
 107     uv__prepare_close((uv_prepare_t*)handle);
 108     break;
 109
 110   case UV_CHECK:
 111     uv__check_close((uv_check_t*)handle);
 112     break;
 113
 114   case UV_IDLE:
 115     uv__idle_close((uv_idle_t*)handle);
 116     break;
 117
 118   case UV_ASYNC:
 119     uv__async_close((uv_async_t*)handle);
 120     break;
 121
 122   case UV_TIMER:
 123     uv__timer_close((uv_timer_t*)handle);
 124     break;
 125
 126   case UV_PROCESS:
 127     uv__process_close((uv_process_t*)handle);
 128     break;
 129
 130   case UV_FS_EVENT:
 131     uv__fs_event_close((uv_fs_event_t*)handle);
 132     break;
 133
 134   case UV_POLL:
 135     uv__poll_close((uv_poll_t*)handle);
 136     break;
 137
 138   case UV_FS_POLL:
 139     uv__fs_poll_close((uv_fs_poll_t*)handle);
 140     break;
 141
 142   case UV_SIGNAL:
 143     uv__signal_close((uv_signal_t*) handle);
 144     /* Signal handles may not be closed immediately. The signal code will */
 145     /* itself close uv__make_close_pending whenever appropriate. */
 146     return;
 147
 148   default:
 149     assert(0);
 150   }
 151
 152   uv__make_close_pending(handle);
 153 }
 154
 155
 156 void uv__make_close_pending(uv_handle_t* handle) {
 157   assert(handle->flags & UV_CLOSING);
 158   assert(!(handle->flags & UV_CLOSED));
 159   handle->next_closing = handle->loop->closing_handles;
 160   handle->loop->closing_handles = handle;
 161 }
 162
 163
 164 static void uv__finish_close(uv_handle_t* handle) {
 165   /* Note: while the handle is in the UV_CLOSING state now, it's still possible
 166    * for it to be active in the sense that uv__is_active() returns true.
 167    * A good example is when the user calls uv_shutdown(), immediately followed
 168    * by uv_close(). The handle is considered active at this point because the
 169    * completion of the shutdown req is still pending.
 170    */
 171   assert(handle->flags & UV_CLOSING);
 172   assert(!(handle->flags & UV_CLOSED));
 173   handle->flags |= UV_CLOSED;
 174
 175   switch (handle->type) {
 176     case UV_PREPARE:
 177     case UV_CHECK:
 178     case UV_IDLE:
 179     case UV_ASYNC:
 180     case UV_TIMER:
 181     case UV_PROCESS:
 182     case UV_FS_EVENT:
 183     case UV_FS_POLL:
 184     case UV_POLL:
 185     case UV_SIGNAL:
 186       break;
 187
 188     case UV_NAMED_PIPE:
 189     case UV_TCP:
 190     case UV_TTY:
 191       uv__stream_destroy((uv_stream_t*)handle);
 192       break;
 193
 194     case UV_UDP:
 195       uv__udp_finish_close((uv_udp_t*)handle);
 196       break;
 197
 198     default:
 199       assert(0);
 200       break;
 201   }
 202
 203   uv__handle_unref(handle);
 204   QUEUE_REMOVE(&handle->handle_queue);
 205
 206   if (handle->close_cb) {
 207     handle->close_cb(handle);
 208   }
 209 }
 210
 211
 212 static void uv__run_closing_handles(uv_loop_t* loop) {
 213   uv_handle_t* p;
 214   uv_handle_t* q;
 215
 216   p = loop->closing_handles;
 217   loop->closing_handles = NULL;
 218
 219   while (p) {
 220     q = p->next_closing;
 221     uv__finish_close(p);
 222     p = q;
 223   }
 224 }
 225
 226
 227 int uv_is_closing(const uv_handle_t* handle) {
 228   return uv__is_closing(handle);
 229 }
 230
 231
 232 uv_loop_t* uv_default_loop(void) {
 233   if (default_loop_ptr)
 234     return default_loop_ptr;
 235
 236   if (uv__loop_init(&default_loop_struct, /* default_loop? */ 1))
 237     return NULL;
 238
 239   return (default_loop_ptr = &default_loop_struct);
 240 }
 241
 242
 243 uv_loop_t* uv_loop_new(void) {
 244   uv_loop_t* loop;
 245
 246   if ((loop = malloc(sizeof(*loop))) == NULL)
 247     return NULL;
 248
 249   if (uv__loop_init(loop, /* default_loop? */ 0)) {
 250     free(loop);
 251     return NULL;
 252   }
 253
 254   return loop;
 255 }
 256
 257
 258 void uv_loop_delete(uv_loop_t* loop) {
 259   uv__loop_delete(loop);
 260 #ifndef NDEBUG
 261   memset(loop, -1, sizeof *loop);
 262 #endif
 263   if (loop == default_loop_ptr)
 264     default_loop_ptr = NULL;
 265   else
 266     free(loop);
 267 }
 268
 269
 270 int uv_backend_fd(const uv_loop_t* loop) {
 271   return loop->backend_fd;
 272 }
 273
 274
 275 int uv_backend_timeout(const uv_loop_t* loop) {
 276   if (loop->stop_flag != 0)
 277     return 0;
 278
 279   if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
 280     return 0;
 281
 282   if (!QUEUE_EMPTY(&loop->idle_handles))
 283     return 0;
 284
 285   if (loop->closing_handles)
 286     return 0;
 287
 288   return uv__next_timeout(loop);
 289 }
 290
 291
 292 static int uv__loop_alive(uv_loop_t* loop) {
 293   return uv__has_active_handles(loop) ||
 294          uv__has_active_reqs(loop) ||
 295          loop->closing_handles != NULL;
 296 }
 297
 298
 299 int uv_run(uv_loop_t* loop, uv_run_mode mode) {
 300   int timeout;
 301   int r;
 302
 303   r = uv__loop_alive(loop);
 304   while (r != 0 && loop->stop_flag == 0) {
 305     UV_TICK_START(loop, mode);
 306
 307     uv__update_time(loop);
 308     uv__run_timers(loop);
 309     uv__run_idle(loop);
 310     uv__run_prepare(loop);
 311     uv__run_pending(loop);
 312
 313     timeout = 0;
 314     if ((mode & UV_RUN_NOWAIT) == 0)
 315       timeout = uv_backend_timeout(loop);
 316
 317     uv__io_poll(loop, timeout);
 318     uv__run_check(loop);
 319     uv__run_closing_handles(loop);
 320
 321     if (mode == UV_RUN_ONCE) {
 322       /* UV_RUN_ONCE implies forward progess: at least one callback must have
 323        * been invoked when it returns. uv__io_poll() can return without doing
 324        * I/O (meaning: no callbacks) when its timeout expires - which means we
 325        * have pending timers that satisfy the forward progress constraint.
 326        *
 327        * UV_RUN_NOWAIT makes no guarantees about progress so it's omitted from
 328        * the check.
 329        */
 330       uv__update_time(loop);
 331       uv__run_timers(loop);
 332     }
 333
 334     r = uv__loop_alive(loop);
 335     UV_TICK_STOP(loop, mode);
 336
 337     if (mode & (UV_RUN_ONCE | UV_RUN_NOWAIT))
 338       break;
 339   }
 340
 341   /* The if statement lets gcc compile it to a conditional store. Avoids
 342    * dirtying a cache line.
 343    */
 344   if (loop->stop_flag != 0)
 345     loop->stop_flag = 0;
 346
 347   return r;
 348 }
 349
 350
 351 void uv_update_time(uv_loop_t* loop) {
 352   uv__update_time(loop);
 353 }
 354
 355
 356 int uv_is_active(const uv_handle_t* handle) {
 357   return uv__is_active(handle);
 358 }
 359
 360
 361 /* Open a socket in non-blocking close-on-exec mode, atomically if possible. */
 362 int uv__socket(int domain, int type, int protocol) {
 363   int sockfd;
 364
 365 #if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
 366   sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
 367
 368   if (sockfd != -1)
 369     goto out;
 370
 371   if (errno != EINVAL)
 372     goto out;
 373 #endif
 374
 375   sockfd = socket(domain, type, protocol);
 376
 377   if (sockfd == -1)
 378     goto out;
 379
 380   if (uv__nonblock(sockfd, 1) || uv__cloexec(sockfd, 1)) {
 381     close(sockfd);
 382     sockfd = -1;
 383   }
 384
 385 #if defined(SO_NOSIGPIPE)
 386   {
 387     int on = 1;
 388     setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
 389   }
 390 #endif
 391
 392 out:
 393   return sockfd;
 394 }
 395
 396
 397 int uv__accept(int sockfd) {
 398   int peerfd;
 399
 400   assert(sockfd >= 0);
 401
 402   while (1) {
 403 #if defined(__linux__)
 404     static int no_accept4;
 405
 406     if (no_accept4)
 407       goto skip;
 408
 409     peerfd = uv__accept4(sockfd,
 410                          NULL,
 411                          NULL,
 412                          UV__SOCK_NONBLOCK|UV__SOCK_CLOEXEC);
 413
 414     if (peerfd != -1)
 415       break;
 416
 417     if (errno == EINTR)
 418       continue;
 419
 420     if (errno != ENOSYS)
 421       break;
 422
 423     no_accept4 = 1;
 424 skip:
 425 #endif
 426
 427     peerfd = accept(sockfd, NULL, NULL);
 428
 429     if (peerfd == -1) {
 430       if (errno == EINTR)
 431         continue;
 432       else
 433         break;
 434     }
 435
 436     if (uv__cloexec(peerfd, 1) || uv__nonblock(peerfd, 1)) {
 437       close(peerfd);
 438       peerfd = -1;
 439     }
 440
 441     break;
 442   }
 443
 444   return peerfd;
 445 }
 446
 447
 448 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
 449
 450 int uv__nonblock(int fd, int set) {
 451   int r;
 452
 453   do
 454     r = ioctl(fd, FIONBIO, &set);
 455   while (r == -1 && errno == EINTR);
 456
 457   return r;
 458 }
 459
 460
 461 int uv__cloexec(int fd, int set) {
 462   int r;
 463
 464   do
 465     r = ioctl(fd, set ? FIOCLEX : FIONCLEX);
 466   while (r == -1 && errno == EINTR);
 467
 468   return r;
 469 }
 470
 471 #else /* !(defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)) */
 472
 473 int uv__nonblock(int fd, int set) {
 474   int flags;
 475   int r;
 476
 477   do
 478     r = fcntl(fd, F_GETFL);
 479   while (r == -1 && errno == EINTR);
 480
 481   if (r == -1)
 482     return -1;
 483
 484   /* Bail out now if already set/clear. */
 485   if (!!(r & O_NONBLOCK) == !!set)
 486     return 0;
 487
 488   if (set)
 489     flags = r | O_NONBLOCK;
 490   else
 491     flags = r & ~O_NONBLOCK;
 492
 493   do
 494     r = fcntl(fd, F_SETFL, flags);
 495   while (r == -1 && errno == EINTR);
 496
 497   return r;
 498 }
 499
 500
 501 int uv__cloexec(int fd, int set) {
 502   int flags;
 503   int r;
 504
 505   do
 506     r = fcntl(fd, F_GETFD);
 507   while (r == -1 && errno == EINTR);
 508
 509   if (r == -1)
 510     return -1;
 511
 512   /* Bail out now if already set/clear. */
 513   if (!!(r & FD_CLOEXEC) == !!set)
 514     return 0;
 515
 516   if (set)
 517     flags = r | FD_CLOEXEC;
 518   else
 519     flags = r & ~FD_CLOEXEC;
 520
 521   do
 522     r = fcntl(fd, F_SETFD, flags);
 523   while (r == -1 && errno == EINTR);
 524
 525   return r;
 526 }
 527
 528 #endif /* defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__) */
 529
 530
 531 /* This function is not execve-safe, there is a race window
 532  * between the call to dup() and fcntl(FD_CLOEXEC).
 533  */
 534 int uv__dup(int fd) {
 535   fd = dup(fd);
 536
 537   if (fd == -1)
 538     return -1;
 539
 540   if (uv__cloexec(fd, 1)) {
 541     SAVE_ERRNO(close(fd));
 542     return -1;
 543   }
 544
 545   return fd;
 546 }
 547
 548
 549 uv_err_t uv_cwd(char* buffer, size_t size) {
 550   if (!buffer || !size) {
 551     return uv__new_artificial_error(UV_EINVAL);
 552   }
 553
 554   if (getcwd(buffer, size)) {
 555     return uv_ok_;
 556   } else {
 557     return uv__new_sys_error(errno);
 558   }
 559 }
 560
 561
 562 uv_err_t uv_chdir(const char* dir) {
 563   if (chdir(dir) == 0) {
 564     return uv_ok_;
 565   } else {
 566     return uv__new_sys_error(errno);
 567   }
 568 }
 569
 570
 571 void uv_disable_stdio_inheritance(void) {
 572   int fd;
 573
 574   /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
 575    * first 16 file descriptors. After that, bail out after the first error.
 576    */
 577   for (fd = 0; ; fd++)
 578     if (uv__cloexec(fd, 1) && fd > 15)
 579       break;
 580 }
 581
 582
 583 static void uv__run_pending(uv_loop_t* loop) {
 584   QUEUE* q;
 585   uv__io_t* w;
 586
 587   while (!QUEUE_EMPTY(&loop->pending_queue)) {
 588     q = QUEUE_HEAD(&loop->pending_queue);
 589     QUEUE_REMOVE(q);
 590     QUEUE_INIT(q);
 591
 592     w = QUEUE_DATA(q, uv__io_t, pending_queue);
 593     w->cb(loop, w, UV__POLLOUT);
 594   }
 595 }
 596
 597
 598 static unsigned int next_power_of_two(unsigned int val) {
 599   val -= 1;
 600   val |= val >> 1;
 601   val |= val >> 2;
 602   val |= val >> 4;
 603   val |= val >> 8;
 604   val |= val >> 16;
 605   val += 1;
 606   return val;
 607 }
 608
 609 static void maybe_resize(uv_loop_t* loop, unsigned int len) {
 610   uv__io_t** watchers;
 611   unsigned int nwatchers;
 612   unsigned int i;
 613
 614   if (len <= loop->nwatchers)
 615     return;
 616
 617   nwatchers = next_power_of_two(len);
 618   watchers = realloc(loop->watchers, nwatchers * sizeof(loop->watchers[0]));
 619
 620   if (watchers == NULL)
 621     abort();
 622
 623   for (i = loop->nwatchers; i < nwatchers; i++)
 624     watchers[i] = NULL;
 625
 626   loop->watchers = watchers;
 627   loop->nwatchers = nwatchers;
 628 }
 629
 630
 631 void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
 632   assert(cb != NULL);
 633   assert(fd >= -1);
 634   QUEUE_INIT(&w->pending_queue);
 635   QUEUE_INIT(&w->watcher_queue);
 636   w->cb = cb;
 637   w->fd = fd;
 638   w->events = 0;
 639   w->pevents = 0;
 640
 641 #if defined(UV_HAVE_KQUEUE)
 642   w->rcount = 0;
 643   w->wcount = 0;
 644 #endif /* defined(UV_HAVE_KQUEUE) */
 645 }
 646
 647
 648 void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 649   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 650   assert(0 != events);
 651   assert(w->fd >= 0);
 652   assert(w->fd < INT_MAX);
 653
 654   w->pevents |= events;
 655   maybe_resize(loop, w->fd + 1);
 656
 657 #if !defined(__sun)
 658   /* The event ports backend needs to rearm all file descriptors on each and
 659    * every tick of the event loop but the other backends allow us to
 660    * short-circuit here if the event mask is unchanged.
 661    */
 662   if (w->events == w->pevents) {
 663     if (w->events == 0 && !QUEUE_EMPTY(&w->watcher_queue)) {
 664       QUEUE_REMOVE(&w->watcher_queue);
 665       QUEUE_INIT(&w->watcher_queue);
 666     }
 667     return;
 668   }
 669 #endif
 670
 671   if (QUEUE_EMPTY(&w->watcher_queue))
 672     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 673
 674   if (loop->watchers[w->fd] == NULL) {
 675     loop->watchers[w->fd] = w;
 676     loop->nfds++;
 677   }
 678 }
 679
 680
 681 void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 682   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 683   assert(0 != events);
 684
 685   if (w->fd == -1)
 686     return;
 687
 688   assert(w->fd >= 0);
 689
 690   /* Happens when uv__io_stop() is called on a handle that was never started. */
 691   if ((unsigned) w->fd >= loop->nwatchers)
 692     return;
 693
 694   w->pevents &= ~events;
 695
 696   if (w->pevents == 0) {
 697     QUEUE_REMOVE(&w->watcher_queue);
 698     QUEUE_INIT(&w->watcher_queue);
 699
 700     if (loop->watchers[w->fd] != NULL) {
 701       assert(loop->watchers[w->fd] == w);
 702       assert(loop->nfds > 0);
 703       loop->watchers[w->fd] = NULL;
 704       loop->nfds--;
 705       w->events = 0;
 706     }
 707   }
 708   else if (QUEUE_EMPTY(&w->watcher_queue))
 709     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 710 }
 711
 712
 713 void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
 714   uv__io_stop(loop, w, UV__POLLIN | UV__POLLOUT);
 715   QUEUE_REMOVE(&w->pending_queue);
 716 }
 717
 718
 719 void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
 720   if (QUEUE_EMPTY(&w->pending_queue))
 721     QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
 722 }
 723
 724
 725 int uv__io_active(const uv__io_t* w, unsigned int events) {
 726   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 727   assert(0 != events);
 728   return 0 != (w->pevents & events);
 729 }