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   ngx_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 (!ngx_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     r = uv__loop_alive(loop);
 321
 322     UV_TICK_STOP(loop, mode);
 323
 324     if (mode & (UV_RUN_ONCE | UV_RUN_NOWAIT))
 325       break;
 326   }
 327
 328   /* The if statement lets gcc compile it to a conditional store. Avoids
 329    * dirtying a cache line.
 330    */
 331   if (loop->stop_flag != 0)
 332     loop->stop_flag = 0;
 333
 334   return r;
 335 }
 336
 337
 338 void uv_update_time(uv_loop_t* loop) {
 339   uv__update_time(loop);
 340 }
 341
 342
 343 int uv_is_active(const uv_handle_t* handle) {
 344   return uv__is_active(handle);
 345 }
 346
 347
 348 /* Open a socket in non-blocking close-on-exec mode, atomically if possible. */
 349 int uv__socket(int domain, int type, int protocol) {
 350   int sockfd;
 351
 352 #if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
 353   sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
 354
 355   if (sockfd != -1)
 356     goto out;
 357
 358   if (errno != EINVAL)
 359     goto out;
 360 #endif
 361
 362   sockfd = socket(domain, type, protocol);
 363
 364   if (sockfd == -1)
 365     goto out;
 366
 367   if (uv__nonblock(sockfd, 1) || uv__cloexec(sockfd, 1)) {
 368     close(sockfd);
 369     sockfd = -1;
 370   }
 371
 372 #if defined(SO_NOSIGPIPE)
 373   {
 374     int on = 1;
 375     setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
 376   }
 377 #endif
 378
 379 out:
 380   return sockfd;
 381 }
 382
 383
 384 int uv__accept(int sockfd) {
 385   int peerfd;
 386
 387   assert(sockfd >= 0);
 388
 389   while (1) {
 390 #if defined(__linux__)
 391     static int no_accept4;
 392
 393     if (no_accept4)
 394       goto skip;
 395
 396     peerfd = uv__accept4(sockfd,
 397                          NULL,
 398                          NULL,
 399                          UV__SOCK_NONBLOCK|UV__SOCK_CLOEXEC);
 400
 401     if (peerfd != -1)
 402       break;
 403
 404     if (errno == EINTR)
 405       continue;
 406
 407     if (errno != ENOSYS)
 408       break;
 409
 410     no_accept4 = 1;
 411 skip:
 412 #endif
 413
 414     peerfd = accept(sockfd, NULL, NULL);
 415
 416     if (peerfd == -1) {
 417       if (errno == EINTR)
 418         continue;
 419       else
 420         break;
 421     }
 422
 423     if (uv__cloexec(peerfd, 1) || uv__nonblock(peerfd, 1)) {
 424       close(peerfd);
 425       peerfd = -1;
 426     }
 427
 428     break;
 429   }
 430
 431   return peerfd;
 432 }
 433
 434
 435 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
 436
 437 int uv__nonblock(int fd, int set) {
 438   int r;
 439
 440   do
 441     r = ioctl(fd, FIONBIO, &set);
 442   while (r == -1 && errno == EINTR);
 443
 444   return r;
 445 }
 446
 447
 448 int uv__cloexec(int fd, int set) {
 449   int r;
 450
 451   do
 452     r = ioctl(fd, set ? FIOCLEX : FIONCLEX);
 453   while (r == -1 && errno == EINTR);
 454
 455   return r;
 456 }
 457
 458 #else /* !(defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)) */
 459
 460 int uv__nonblock(int fd, int set) {
 461   int flags;
 462   int r;
 463
 464   do
 465     r = fcntl(fd, F_GETFL);
 466   while (r == -1 && errno == EINTR);
 467
 468   if (r == -1)
 469     return -1;
 470
 471   /* Bail out now if already set/clear. */
 472   if (!!(r & O_NONBLOCK) == !!set)
 473     return 0;
 474
 475   if (set)
 476     flags = r | O_NONBLOCK;
 477   else
 478     flags = r & ~O_NONBLOCK;
 479
 480   do
 481     r = fcntl(fd, F_SETFL, flags);
 482   while (r == -1 && errno == EINTR);
 483
 484   return r;
 485 }
 486
 487
 488 int uv__cloexec(int fd, int set) {
 489   int flags;
 490   int r;
 491
 492   do
 493     r = fcntl(fd, F_GETFD);
 494   while (r == -1 && errno == EINTR);
 495
 496   if (r == -1)
 497     return -1;
 498
 499   /* Bail out now if already set/clear. */
 500   if (!!(r & FD_CLOEXEC) == !!set)
 501     return 0;
 502
 503   if (set)
 504     flags = r | FD_CLOEXEC;
 505   else
 506     flags = r & ~FD_CLOEXEC;
 507
 508   do
 509     r = fcntl(fd, F_SETFD, flags);
 510   while (r == -1 && errno == EINTR);
 511
 512   return r;
 513 }
 514
 515 #endif /* defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__) */
 516
 517
 518 /* This function is not execve-safe, there is a race window
 519  * between the call to dup() and fcntl(FD_CLOEXEC).
 520  */
 521 int uv__dup(int fd) {
 522   fd = dup(fd);
 523
 524   if (fd == -1)
 525     return -1;
 526
 527   if (uv__cloexec(fd, 1)) {
 528     SAVE_ERRNO(close(fd));
 529     return -1;
 530   }
 531
 532   return fd;
 533 }
 534
 535
 536 uv_err_t uv_cwd(char* buffer, size_t size) {
 537   if (!buffer || !size) {
 538     return uv__new_artificial_error(UV_EINVAL);
 539   }
 540
 541   if (getcwd(buffer, size)) {
 542     return uv_ok_;
 543   } else {
 544     return uv__new_sys_error(errno);
 545   }
 546 }
 547
 548
 549 uv_err_t uv_chdir(const char* dir) {
 550   if (chdir(dir) == 0) {
 551     return uv_ok_;
 552   } else {
 553     return uv__new_sys_error(errno);
 554   }
 555 }
 556
 557
 558 void uv_disable_stdio_inheritance(void) {
 559   int fd;
 560
 561   /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
 562    * first 16 file descriptors. After that, bail out after the first error.
 563    */
 564   for (fd = 0; ; fd++)
 565     if (uv__cloexec(fd, 1) && fd > 15)
 566       break;
 567 }
 568
 569
 570 static void uv__run_pending(uv_loop_t* loop) {
 571   ngx_queue_t* q;
 572   uv__io_t* w;
 573
 574   while (!ngx_queue_empty(&loop->pending_queue)) {
 575     q = ngx_queue_head(&loop->pending_queue);
 576     ngx_queue_remove(q);
 577     ngx_queue_init(q);
 578
 579     w = ngx_queue_data(q, uv__io_t, pending_queue);
 580     w->cb(loop, w, UV__POLLOUT);
 581   }
 582 }
 583
 584
 585 static unsigned int next_power_of_two(unsigned int val) {
 586   val -= 1;
 587   val |= val >> 1;
 588   val |= val >> 2;
 589   val |= val >> 4;
 590   val |= val >> 8;
 591   val |= val >> 16;
 592   val += 1;
 593   return val;
 594 }
 595
 596 static void maybe_resize(uv_loop_t* loop, unsigned int len) {
 597   uv__io_t** watchers;
 598   void* fake_watcher_list;
 599   void* fake_watcher_count;
 600   unsigned int nwatchers;
 601   unsigned int i;
 602
 603   if (len <= loop->nwatchers)
 604     return;
 605
 606   /* Preserve fake watcher list and count at the end of the watchers */
 607   if (loop->watchers != NULL) {
 608     fake_watcher_list = loop->watchers[loop->nwatchers];
 609     fake_watcher_count = loop->watchers[loop->nwatchers + 1];
 610   } else {
 611     fake_watcher_list = NULL;
 612     fake_watcher_count = NULL;
 613   }
 614
 615   nwatchers = next_power_of_two(len + 2) - 2;
 616   watchers = realloc(loop->watchers,
 617                      (nwatchers + 2) * sizeof(loop->watchers[0]));
 618
 619   if (watchers == NULL)
 620     abort();
 621   for (i = loop->nwatchers; i < nwatchers; i++)
 622     watchers[i] = NULL;
 623   watchers[nwatchers] = fake_watcher_list;
 624   watchers[nwatchers + 1] = fake_watcher_count;
 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   ngx_queue_init(&w->pending_queue);
 635   ngx_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 && !ngx_queue_empty(&w->watcher_queue)) {
 664       ngx_queue_remove(&w->watcher_queue);
 665       ngx_queue_init(&w->watcher_queue);
 666     }
 667     return;
 668   }
 669 #endif
 670
 671   if (ngx_queue_empty(&w->watcher_queue))
 672     ngx_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     ngx_queue_remove(&w->watcher_queue);
 698     ngx_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 (ngx_queue_empty(&w->watcher_queue))
 709     ngx_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   ngx_queue_remove(&w->pending_queue);
 716
 717   /* Remove stale events for this file descriptor */
 718   uv__platform_invalidate_fd(loop, w->fd);
 719 }
 720
 721
 722 void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
 723   if (ngx_queue_empty(&w->pending_queue))
 724     ngx_queue_insert_tail(&loop->pending_queue, &w->pending_queue);
 725 }
 726
 727
 728 int uv__io_active(const uv__io_t* w, unsigned int events) {
 729   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 730   assert(0 != events);
 731   return 0 != (w->pevents & events);
 732 }