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