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   assert(!uv__is_active(handle));
 166   assert(handle->flags & UV_CLOSING);
 167   assert(!(handle->flags & UV_CLOSED));
 168   handle->flags |= UV_CLOSED;
 169
 170   switch (handle->type) {
 171     case UV_PREPARE:
 172     case UV_CHECK:
 173     case UV_IDLE:
 174     case UV_ASYNC:
 175     case UV_TIMER:
 176     case UV_PROCESS:
 177     case UV_FS_EVENT:
 178     case UV_FS_POLL:
 179     case UV_POLL:
 180     case UV_SIGNAL:
 181       break;
 182
 183     case UV_NAMED_PIPE:
 184     case UV_TCP:
 185     case UV_TTY:
 186       uv__stream_destroy((uv_stream_t*)handle);
 187       break;
 188
 189     case UV_UDP:
 190       uv__udp_finish_close((uv_udp_t*)handle);
 191       break;
 192
 193     default:
 194       assert(0);
 195       break;
 196   }
 197
 198   uv__handle_unref(handle);
 199   QUEUE_REMOVE(&handle->handle_queue);
 200
 201   if (handle->close_cb) {
 202     handle->close_cb(handle);
 203   }
 204 }
 205
 206
 207 static void uv__run_closing_handles(uv_loop_t* loop) {
 208   uv_handle_t* p;
 209   uv_handle_t* q;
 210
 211   p = loop->closing_handles;
 212   loop->closing_handles = NULL;
 213
 214   while (p) {
 215     q = p->next_closing;
 216     uv__finish_close(p);
 217     p = q;
 218   }
 219 }
 220
 221
 222 int uv_is_closing(const uv_handle_t* handle) {
 223   return handle->flags & (UV_CLOSING | UV_CLOSED);
 224 }
 225
 226
 227 uv_loop_t* uv_default_loop(void) {
 228   if (default_loop_ptr)
 229     return default_loop_ptr;
 230
 231   if (uv__loop_init(&default_loop_struct, /* default_loop? */ 1))
 232     return NULL;
 233
 234   return (default_loop_ptr = &default_loop_struct);
 235 }
 236
 237
 238 uv_loop_t* uv_loop_new(void) {
 239   uv_loop_t* loop;
 240
 241   if ((loop = malloc(sizeof(*loop))) == NULL)
 242     return NULL;
 243
 244   if (uv__loop_init(loop, /* default_loop? */ 0)) {
 245     free(loop);
 246     return NULL;
 247   }
 248
 249   return loop;
 250 }
 251
 252
 253 void uv_loop_delete(uv_loop_t* loop) {
 254   uv__loop_delete(loop);
 255 #ifndef NDEBUG
 256   memset(loop, -1, sizeof *loop);
 257 #endif
 258   if (loop == default_loop_ptr)
 259     default_loop_ptr = NULL;
 260   else
 261     free(loop);
 262 }
 263
 264
 265 int uv_backend_fd(const uv_loop_t* loop) {
 266   return loop->backend_fd;
 267 }
 268
 269
 270 int uv_backend_timeout(const uv_loop_t* loop) {
 271   if (loop->stop_flag != 0)
 272     return 0;
 273
 274   if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
 275     return 0;
 276
 277   if (!QUEUE_EMPTY(&loop->idle_handles))
 278     return 0;
 279
 280   if (loop->closing_handles)
 281     return 0;
 282
 283   return uv__next_timeout(loop);
 284 }
 285
 286
 287 static int uv__loop_alive(uv_loop_t* loop) {
 288   return uv__has_active_handles(loop) ||
 289          uv__has_active_reqs(loop) ||
 290          loop->closing_handles != NULL;
 291 }
 292
 293
 294 int uv_run(uv_loop_t* loop, uv_run_mode mode) {
 295   int timeout;
 296   int r;
 297
 298   r = uv__loop_alive(loop);
 299   while (r != 0 && loop->stop_flag == 0) {
 300     UV_TICK_START(loop, mode);
 301
 302     uv__update_time(loop);
 303     uv__run_timers(loop);
 304     uv__run_idle(loop);
 305     uv__run_prepare(loop);
 306     uv__run_pending(loop);
 307
 308     timeout = 0;
 309     if ((mode & UV_RUN_NOWAIT) == 0)
 310       timeout = uv_backend_timeout(loop);
 311
 312     uv__io_poll(loop, timeout);
 313     uv__run_check(loop);
 314     uv__run_closing_handles(loop);
 315     r = uv__loop_alive(loop);
 316
 317     UV_TICK_STOP(loop, mode);
 318
 319     if (mode & (UV_RUN_ONCE | UV_RUN_NOWAIT))
 320       break;
 321   }
 322
 323   /* The if statement lets gcc compile it to a conditional store. Avoids
 324    * dirtying a cache line.
 325    */
 326   if (loop->stop_flag != 0)
 327     loop->stop_flag = 0;
 328
 329   return r;
 330 }
 331
 332
 333 void uv_update_time(uv_loop_t* loop) {
 334   uv__update_time(loop);
 335 }
 336
 337
 338 uint64_t uv_now(uv_loop_t* loop) {
 339   return loop->time;
 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   QUEUE* q;
 572   uv__io_t* w;
 573
 574   while (!QUEUE_EMPTY(&loop->pending_queue)) {
 575     q = QUEUE_HEAD(&loop->pending_queue);
 576     QUEUE_REMOVE(q);
 577     QUEUE_INIT(q);
 578
 579     w = 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   unsigned int nwatchers;
 599   unsigned int i;
 600
 601   if (len <= loop->nwatchers)
 602     return;
 603
 604   nwatchers = next_power_of_two(len);
 605   watchers = realloc(loop->watchers, nwatchers * sizeof(loop->watchers[0]));
 606
 607   if (watchers == NULL)
 608     abort();
 609
 610   for (i = loop->nwatchers; i < nwatchers; i++)
 611     watchers[i] = NULL;
 612
 613   loop->watchers = watchers;
 614   loop->nwatchers = nwatchers;
 615 }
 616
 617
 618 void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
 619   assert(cb != NULL);
 620   assert(fd >= -1);
 621   QUEUE_INIT(&w->pending_queue);
 622   QUEUE_INIT(&w->watcher_queue);
 623   w->cb = cb;
 624   w->fd = fd;
 625   w->events = 0;
 626   w->pevents = 0;
 627
 628 #if defined(UV_HAVE_KQUEUE)
 629   w->rcount = 0;
 630   w->wcount = 0;
 631 #endif /* defined(UV_HAVE_KQUEUE) */
 632 }
 633
 634
 635 void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 636   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 637   assert(0 != events);
 638   assert(w->fd >= 0);
 639   assert(w->fd < INT_MAX);
 640
 641   w->pevents |= events;
 642   maybe_resize(loop, w->fd + 1);
 643
 644 #if !defined(__sun)
 645   /* The event ports backend needs to rearm all file descriptors on each and
 646    * every tick of the event loop but the other backends allow us to
 647    * short-circuit here if the event mask is unchanged.
 648    */
 649   if (w->events == w->pevents) {
 650     if (w->events == 0 && !QUEUE_EMPTY(&w->watcher_queue)) {
 651       QUEUE_REMOVE(&w->watcher_queue);
 652       QUEUE_INIT(&w->watcher_queue);
 653     }
 654     return;
 655   }
 656 #endif
 657
 658   if (QUEUE_EMPTY(&w->watcher_queue))
 659     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 660
 661   if (loop->watchers[w->fd] == NULL) {
 662     loop->watchers[w->fd] = w;
 663     loop->nfds++;
 664   }
 665 }
 666
 667
 668 void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 669   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 670   assert(0 != events);
 671
 672   if (w->fd == -1)
 673     return;
 674
 675   assert(w->fd >= 0);
 676
 677   /* Happens when uv__io_stop() is called on a handle that was never started. */
 678   if ((unsigned) w->fd >= loop->nwatchers)
 679     return;
 680
 681   w->pevents &= ~events;
 682
 683   if (w->pevents == 0) {
 684     QUEUE_REMOVE(&w->watcher_queue);
 685     QUEUE_INIT(&w->watcher_queue);
 686
 687     if (loop->watchers[w->fd] != NULL) {
 688       assert(loop->watchers[w->fd] == w);
 689       assert(loop->nfds > 0);
 690       loop->watchers[w->fd] = NULL;
 691       loop->nfds--;
 692       w->events = 0;
 693     }
 694   }
 695   else if (QUEUE_EMPTY(&w->watcher_queue))
 696     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 697 }
 698
 699
 700 void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
 701   uv__io_stop(loop, w, UV__POLLIN | UV__POLLOUT);
 702   QUEUE_REMOVE(&w->pending_queue);
 703 }
 704
 705
 706 void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
 707   if (QUEUE_EMPTY(&w->pending_queue))
 708     QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
 709 }
 710
 711
 712 int uv__io_active(const uv__io_t* w, unsigned int events) {
 713   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 714   assert(0 != events);
 715   return 0 != (w->pevents & events);
 716 }