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__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     if (mode & (UV_RUN_ONCE | UV_RUN_NOWAIT))
 318       break;
 319   }
 320
 321   /* The if statement lets gcc compile it to a conditional store. Avoids
 322    * dirtying a cache line.
 323    */
 324   if (loop->stop_flag != 0)
 325     loop->stop_flag = 0;
 326
 327   return r;
 328 }
 329
 330
 331 void uv_update_time(uv_loop_t* loop) {
 332   uv__update_time(loop);
 333 }
 334
 335
 336 uint64_t uv_now(uv_loop_t* loop) {
 337   return loop->time;
 338 }
 339
 340
 341 int uv_is_active(const uv_handle_t* handle) {
 342   return uv__is_active(handle);
 343 }
 344
 345
 346 /* Open a socket in non-blocking close-on-exec mode, atomically if possible. */
 347 int uv__socket(int domain, int type, int protocol) {
 348   int sockfd;
 349
 350 #if defined(SOCK_NONBLOCK) && defined(SOCK_CLOEXEC)
 351   sockfd = socket(domain, type | SOCK_NONBLOCK | SOCK_CLOEXEC, protocol);
 352
 353   if (sockfd != -1)
 354     goto out;
 355
 356   if (errno != EINVAL)
 357     goto out;
 358 #endif
 359
 360   sockfd = socket(domain, type, protocol);
 361
 362   if (sockfd == -1)
 363     goto out;
 364
 365   if (uv__nonblock(sockfd, 1) || uv__cloexec(sockfd, 1)) {
 366     close(sockfd);
 367     sockfd = -1;
 368   }
 369
 370 #if defined(SO_NOSIGPIPE)
 371   {
 372     int on = 1;
 373     setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof(on));
 374   }
 375 #endif
 376
 377 out:
 378   return sockfd;
 379 }
 380
 381
 382 int uv__accept(int sockfd) {
 383   int peerfd;
 384
 385   assert(sockfd >= 0);
 386
 387   while (1) {
 388 #if defined(__linux__)
 389     static int no_accept4;
 390
 391     if (no_accept4)
 392       goto skip;
 393
 394     peerfd = uv__accept4(sockfd,
 395                          NULL,
 396                          NULL,
 397                          UV__SOCK_NONBLOCK|UV__SOCK_CLOEXEC);
 398
 399     if (peerfd != -1)
 400       break;
 401
 402     if (errno == EINTR)
 403       continue;
 404
 405     if (errno != ENOSYS)
 406       break;
 407
 408     no_accept4 = 1;
 409 skip:
 410 #endif
 411
 412     peerfd = accept(sockfd, NULL, NULL);
 413
 414     if (peerfd == -1) {
 415       if (errno == EINTR)
 416         continue;
 417       else
 418         break;
 419     }
 420
 421     if (uv__cloexec(peerfd, 1) || uv__nonblock(peerfd, 1)) {
 422       close(peerfd);
 423       peerfd = -1;
 424     }
 425
 426     break;
 427   }
 428
 429   return peerfd;
 430 }
 431
 432
 433 #if defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)
 434
 435 int uv__nonblock(int fd, int set) {
 436   int r;
 437
 438   do
 439     r = ioctl(fd, FIONBIO, &set);
 440   while (r == -1 && errno == EINTR);
 441
 442   return r;
 443 }
 444
 445
 446 int uv__cloexec(int fd, int set) {
 447   int r;
 448
 449   do
 450     r = ioctl(fd, set ? FIOCLEX : FIONCLEX);
 451   while (r == -1 && errno == EINTR);
 452
 453   return r;
 454 }
 455
 456 #else /* !(defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__)) */
 457
 458 int uv__nonblock(int fd, int set) {
 459   int flags;
 460   int r;
 461
 462   do
 463     r = fcntl(fd, F_GETFL);
 464   while (r == -1 && errno == EINTR);
 465
 466   if (r == -1)
 467     return -1;
 468
 469   /* Bail out now if already set/clear. */
 470   if (!!(r & O_NONBLOCK) == !!set)
 471     return 0;
 472
 473   if (set)
 474     flags = r | O_NONBLOCK;
 475   else
 476     flags = r & ~O_NONBLOCK;
 477
 478   do
 479     r = fcntl(fd, F_SETFL, flags);
 480   while (r == -1 && errno == EINTR);
 481
 482   return r;
 483 }
 484
 485
 486 int uv__cloexec(int fd, int set) {
 487   int flags;
 488   int r;
 489
 490   do
 491     r = fcntl(fd, F_GETFD);
 492   while (r == -1 && errno == EINTR);
 493
 494   if (r == -1)
 495     return -1;
 496
 497   /* Bail out now if already set/clear. */
 498   if (!!(r & FD_CLOEXEC) == !!set)
 499     return 0;
 500
 501   if (set)
 502     flags = r | FD_CLOEXEC;
 503   else
 504     flags = r & ~FD_CLOEXEC;
 505
 506   do
 507     r = fcntl(fd, F_SETFD, flags);
 508   while (r == -1 && errno == EINTR);
 509
 510   return r;
 511 }
 512
 513 #endif /* defined(__linux__) || defined(__FreeBSD__) || defined(__APPLE__) */
 514
 515
 516 /* This function is not execve-safe, there is a race window
 517  * between the call to dup() and fcntl(FD_CLOEXEC).
 518  */
 519 int uv__dup(int fd) {
 520   fd = dup(fd);
 521
 522   if (fd == -1)
 523     return -1;
 524
 525   if (uv__cloexec(fd, 1)) {
 526     SAVE_ERRNO(close(fd));
 527     return -1;
 528   }
 529
 530   return fd;
 531 }
 532
 533
 534 uv_err_t uv_cwd(char* buffer, size_t size) {
 535   if (!buffer || !size) {
 536     return uv__new_artificial_error(UV_EINVAL);
 537   }
 538
 539   if (getcwd(buffer, size)) {
 540     return uv_ok_;
 541   } else {
 542     return uv__new_sys_error(errno);
 543   }
 544 }
 545
 546
 547 uv_err_t uv_chdir(const char* dir) {
 548   if (chdir(dir) == 0) {
 549     return uv_ok_;
 550   } else {
 551     return uv__new_sys_error(errno);
 552   }
 553 }
 554
 555
 556 void uv_disable_stdio_inheritance(void) {
 557   int fd;
 558
 559   /* Set the CLOEXEC flag on all open descriptors. Unconditionally try the
 560    * first 16 file descriptors. After that, bail out after the first error.
 561    */
 562   for (fd = 0; ; fd++)
 563     if (uv__cloexec(fd, 1) && fd > 15)
 564       break;
 565 }
 566
 567
 568 static void uv__run_pending(uv_loop_t* loop) {
 569   QUEUE* q;
 570   uv__io_t* w;
 571
 572   while (!QUEUE_EMPTY(&loop->pending_queue)) {
 573     q = QUEUE_HEAD(&loop->pending_queue);
 574     QUEUE_REMOVE(q);
 575     QUEUE_INIT(q);
 576
 577     w = QUEUE_DATA(q, uv__io_t, pending_queue);
 578     w->cb(loop, w, UV__POLLOUT);
 579   }
 580 }
 581
 582
 583 static unsigned int next_power_of_two(unsigned int val) {
 584   val -= 1;
 585   val |= val >> 1;
 586   val |= val >> 2;
 587   val |= val >> 4;
 588   val |= val >> 8;
 589   val |= val >> 16;
 590   val += 1;
 591   return val;
 592 }
 593
 594 static void maybe_resize(uv_loop_t* loop, unsigned int len) {
 595   uv__io_t** watchers;
 596   unsigned int nwatchers;
 597   unsigned int i;
 598
 599   if (len <= loop->nwatchers)
 600     return;
 601
 602   nwatchers = next_power_of_two(len);
 603   watchers = realloc(loop->watchers, nwatchers * sizeof(loop->watchers[0]));
 604
 605   if (watchers == NULL)
 606     abort();
 607
 608   for (i = loop->nwatchers; i < nwatchers; i++)
 609     watchers[i] = NULL;
 610
 611   loop->watchers = watchers;
 612   loop->nwatchers = nwatchers;
 613 }
 614
 615
 616 void uv__io_init(uv__io_t* w, uv__io_cb cb, int fd) {
 617   assert(cb != NULL);
 618   assert(fd >= -1);
 619   QUEUE_INIT(&w->pending_queue);
 620   QUEUE_INIT(&w->watcher_queue);
 621   w->cb = cb;
 622   w->fd = fd;
 623   w->events = 0;
 624   w->pevents = 0;
 625
 626 #if defined(UV_HAVE_KQUEUE)
 627   w->rcount = 0;
 628   w->wcount = 0;
 629 #endif /* defined(UV_HAVE_KQUEUE) */
 630 }
 631
 632
 633 void uv__io_start(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 634   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 635   assert(0 != events);
 636   assert(w->fd >= 0);
 637   assert(w->fd < INT_MAX);
 638
 639   w->pevents |= events;
 640   maybe_resize(loop, w->fd + 1);
 641
 642 #if !defined(__sun)
 643   /* The event ports backend needs to rearm all file descriptors on each and
 644    * every tick of the event loop but the other backends allow us to
 645    * short-circuit here if the event mask is unchanged.
 646    */
 647   if (w->events == w->pevents) {
 648     if (w->events == 0 && !QUEUE_EMPTY(&w->watcher_queue)) {
 649       QUEUE_REMOVE(&w->watcher_queue);
 650       QUEUE_INIT(&w->watcher_queue);
 651     }
 652     return;
 653   }
 654 #endif
 655
 656   if (QUEUE_EMPTY(&w->watcher_queue))
 657     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 658
 659   if (loop->watchers[w->fd] == NULL) {
 660     loop->watchers[w->fd] = w;
 661     loop->nfds++;
 662   }
 663 }
 664
 665
 666 void uv__io_stop(uv_loop_t* loop, uv__io_t* w, unsigned int events) {
 667   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 668   assert(0 != events);
 669
 670   if (w->fd == -1)
 671     return;
 672
 673   assert(w->fd >= 0);
 674
 675   /* Happens when uv__io_stop() is called on a handle that was never started. */
 676   if ((unsigned) w->fd >= loop->nwatchers)
 677     return;
 678
 679   w->pevents &= ~events;
 680
 681   if (w->pevents == 0) {
 682     QUEUE_REMOVE(&w->watcher_queue);
 683     QUEUE_INIT(&w->watcher_queue);
 684
 685     if (loop->watchers[w->fd] != NULL) {
 686       assert(loop->watchers[w->fd] == w);
 687       assert(loop->nfds > 0);
 688       loop->watchers[w->fd] = NULL;
 689       loop->nfds--;
 690       w->events = 0;
 691     }
 692   }
 693   else if (QUEUE_EMPTY(&w->watcher_queue))
 694     QUEUE_INSERT_TAIL(&loop->watcher_queue, &w->watcher_queue);
 695 }
 696
 697
 698 void uv__io_close(uv_loop_t* loop, uv__io_t* w) {
 699   uv__io_stop(loop, w, UV__POLLIN | UV__POLLOUT);
 700   QUEUE_REMOVE(&w->pending_queue);
 701 }
 702
 703
 704 void uv__io_feed(uv_loop_t* loop, uv__io_t* w) {
 705   if (QUEUE_EMPTY(&w->pending_queue))
 706     QUEUE_INSERT_TAIL(&loop->pending_queue, &w->pending_queue);
 707 }
 708
 709
 710 int uv__io_active(const uv__io_t* w, unsigned int events) {
 711   assert(0 == (events & ~(UV__POLLIN | UV__POLLOUT)));
 712   assert(0 != events);
 713   return 0 != (w->pevents & events);
 714 }