process.c File Reference

#include "uv.h"
#include "internal.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>

Go to the source code of this file.

Functions
static void	uv__chld (uv_signal_t *handle, int signum)
static int	uv__make_socketpair (int fds[2])
int	uv__make_pipe (int fds[2], int flags)
static int	uv__process_init_stdio (uv_stdio_container_t *container, int fds[2])
static int	uv__process_open_stream (uv_stdio_container_t *container, int pipefds[2])
static void	uv__process_close_stream (uv_stdio_container_t *container)
static void	uv__write_int (int fd, int val)
static void	uv__process_child_init (const uv_process_options_t *options, int stdio_count, int(*pipes)[2], int error_fd)
int	uv_spawn (uv_loop_t *loop, uv_process_t *process, const uv_process_options_t *options)
int	uv_process_kill (uv_process_t *process, int signum)
int	uv_kill (int pid, int signum)
void	uv__process_close (uv_process_t *handle)

Variables
char **	environ

Function Documentation

uv__chld()

static void uv__chld ( uv_signal_t *  handle, int  signum  )

static

Definition at line 48 of file process.c.

                                                      {
  uv_process_t* process;
  uv_loop_t* loop;
  int exit_status;
  int term_signal;
  int status;
  pid_t pid;
  QUEUE pending;
  QUEUE* q;
  QUEUE* h;
 
  assert(signum == SIGCHLD);
 
  QUEUE_INIT(&pending);
  loop = handle->loop;
 
  h = &loop->process_handles;
  q = QUEUE_HEAD(h);
  while (q != h) {
    process = QUEUE_DATA(q, uv_process_t, queue);
    q = QUEUE_NEXT(q);
 
    do
      pid = waitpid(process->pid, &status, WNOHANG);
    while (pid == -1 && errno == EINTR);
 
    if (pid == 0)
      continue;
 
    if (pid == -1) {
      if (errno != ECHILD)
        abort();
      continue;
    }
 
    process->status = status;
    QUEUE_REMOVE(&process->queue);
    QUEUE_INSERT_TAIL(&pending, &process->queue);
  }
 
  h = &pending;
  q = QUEUE_HEAD(h);
  while (q != h) {
    process = QUEUE_DATA(q, uv_process_t, queue);
    q = QUEUE_NEXT(q);
 
    QUEUE_REMOVE(&process->queue);
    QUEUE_INIT(&process->queue);
    uv__handle_stop(process);
 
    if (process->exit_cb == NULL)
      continue;
 
    exit_status = 0;
    if (WIFEXITED(process->status))
      exit_status = WEXITSTATUS(process->status);
 
    term_signal = 0;
    if (WIFSIGNALED(process->status))
      term_signal = WTERMSIG(process->status);
 
    process->exit_cb(process, exit_status, term_signal);
  }
  assert(QUEUE_EMPTY(&pending));
}

References assert(), ECHILD, EINTR, exit_status, h, handle, loop, NULL, pid, process(), queue, QUEUE_DATA, QUEUE_EMPTY, QUEUE_HEAD, QUEUE_INIT, QUEUE_INSERT_TAIL, QUEUE_NEXT, QUEUE_REMOVE, signum, status, and uv__handle_stop.

Referenced by uv_spawn().

uv__make_pipe()

int uv__make_pipe	(	int	fds[2],
		int	flags
	)

Definition at line 142 of file process.c.

                                         {
#if defined(__FreeBSD__) || defined(__linux__)
  if (pipe2(fds, flags | O_CLOEXEC))
    return UV__ERR(errno);
 
  return 0;
#else
  if (pipe(fds))
    return UV__ERR(errno);
 
  if (uv__cloexec(fds[0], 1))
    goto fail;
 
  if (uv__cloexec(fds[1], 1))
    goto fail;
 
  if (flags & UV__F_NONBLOCK) {
    if (uv__nonblock(fds[0], 1))
      goto fail;
 
    if (uv__nonblock(fds[1], 1))
      goto fail;
  }
 
  return 0;
 
fail:
  uv__close(fds[0]);
  uv__close(fds[1]);
  return UV__ERR(errno);
#endif
}

References fail, flags, O_CLOEXEC, pipe, uv__cloexec, uv__close(), UV__ERR, UV__F_NONBLOCK, and uv__nonblock.

Referenced by uv__async_start(), uv__signal_global_reinit(), uv__signal_loop_once_init(), and uv_spawn().

uv__make_socketpair()

static int uv__make_socketpair ( int  fds[2] )

static

Definition at line 115 of file process.c.

                                           {
#if defined(__FreeBSD__) || defined(__linux__)
  if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fds))
    return UV__ERR(errno);
 
  return 0;
#else
  int err;
 
  if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds))
    return UV__ERR(errno);
 
  err = uv__cloexec(fds[0], 1);
  if (err == 0)
    err = uv__cloexec(fds[1], 1);
 
  if (err != 0) {
    uv__close(fds[0]);
    uv__close(fds[1]);
    return UV__ERR(errno);
  }
 
  return 0;
#endif
}

References AF_UNIX, err, SOCK_STREAM, uv__cloexec, uv__close(), and UV__ERR.

Referenced by uv__process_init_stdio().

uv__process_child_init()

static void uv__process_child_init ( const uv_process_options_t *  options, int  stdio_count, int(*)  pipes[2], int  error_fd  )

static

Definition at line 267 of file process.c.

                                                 {
  sigset_t set;
  int close_fd;
  int use_fd;
  int err;
  int fd;
  int n;
 
  if (options->flags & UV_PROCESS_DETACHED)
    setsid();
 
  /* First duplicate low numbered fds, since it's not safe to duplicate them,
   * they could get replaced. Example: swapping stdout and stderr; without
   * this fd 2 (stderr) would be duplicated into fd 1, thus making both
   * stdout and stderr go to the same fd, which was not the intention. */
  for (fd = 0; fd < stdio_count; fd++) {
    use_fd = pipes[fd][1];
    if (use_fd < 0 || use_fd >= fd)
      continue;
    pipes[fd][1] = fcntl(use_fd, F_DUPFD, stdio_count);
    if (pipes[fd][1] == -1) {
      uv__write_int(error_fd, UV__ERR(errno));
      _exit(127);
    }
  }
 
  for (fd = 0; fd < stdio_count; fd++) {
    close_fd = pipes[fd][0];
    use_fd = pipes[fd][1];
 
    if (use_fd < 0) {
      if (fd >= 3)
        continue;
      else {
        /* redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is
         * set
         */
        use_fd = open("/dev/null", fd == 0 ? O_RDONLY : O_RDWR);
        close_fd = use_fd;
 
        if (use_fd < 0) {
          uv__write_int(error_fd, UV__ERR(errno));
          _exit(127);
        }
      }
    }
 
    if (fd == use_fd)
      uv__cloexec_fcntl(use_fd, 0);
    else
      fd = dup2(use_fd, fd);
 
    if (fd == -1) {
      uv__write_int(error_fd, UV__ERR(errno));
      _exit(127);
    }
 
    if (fd <= 2)
      uv__nonblock_fcntl(fd, 0);
 
    if (close_fd >= stdio_count)
      uv__close(close_fd);
  }
 
  for (fd = 0; fd < stdio_count; fd++) {
    use_fd = pipes[fd][1];
 
    if (use_fd >= stdio_count)
      uv__close(use_fd);
  }
 
  if (options->cwd != NULL && chdir(options->cwd)) {
    uv__write_int(error_fd, UV__ERR(errno));
    _exit(127);
  }
 
  if (options->flags & (UV_PROCESS_SETUID | UV_PROCESS_SETGID)) {
    /* When dropping privileges from root, the `setgroups` call will
     * remove any extraneous groups. If we don't call this, then
     * even though our uid has dropped, we may still have groups
     * that enable us to do super-user things. This will fail if we
     * aren't root, so don't bother checking the return value, this
     * is just done as an optimistic privilege dropping function.
     */
    SAVE_ERRNO(setgroups(0, NULL));
  }
 
  if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid)) {
    uv__write_int(error_fd, UV__ERR(errno));
    _exit(127);
  }
 
  if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid)) {
    uv__write_int(error_fd, UV__ERR(errno));
    _exit(127);
  }
 
  if (options->env != NULL) {
    environ = options->env;
  }
 
  /* Reset signal disposition.  Use a hard-coded limit because NSIG
   * is not fixed on Linux: it's either 32, 34 or 64, depending on
   * whether RT signals are enabled.  We are not allowed to touch
   * RT signal handlers, glibc uses them internally.
   */
  for (n = 1; n < 32; n += 1) {
    if (n == SIGKILL || n == SIGSTOP)
      continue;  /* Can't be changed. */
 
#if defined(__HAIKU__)
    if (n == SIGKILLTHR)
      continue;  /* Can't be changed. */
#endif
 
    if (SIG_ERR != signal(n, SIG_DFL))
      continue;
 
    uv__write_int(error_fd, UV__ERR(errno));
    _exit(127);
  }
 
  /* Reset signal mask. */
  sigemptyset(&set);
  err = pthread_sigmask(SIG_SETMASK, &set, NULL);
 
  if (err != 0) {
    uv__write_int(error_fd, UV__ERR(err));
    _exit(127);
  }
 
  execvp(options->file, options->args);
  uv__write_int(error_fd, UV__ERR(errno));
  _exit(127);
}

References chdir, dup2, environ, err, F_DUPFD, fcntl, fd, n, NULL, O_RDONLY, O_RDWR, options, SAVE_ERRNO, setgid, setgroups, SIGKILL, signal, uv__cloexec_fcntl(), uv__close(), UV__ERR, uv__nonblock_fcntl(), uv__write_int(), UV_PROCESS_DETACHED, UV_PROCESS_SETGID, and UV_PROCESS_SETUID.

Referenced by uv_spawn().

uv__process_close()

void uv__process_close

(

uv_process_t *

handle

)

Definition at line 590 of file process.c.

                                             {
  QUEUE_REMOVE(&handle->queue);
  uv__handle_stop(handle);
  if (QUEUE_EMPTY(&handle->loop->process_handles))
    uv_signal_stop(&handle->loop->child_watcher);
}

References handle, QUEUE_EMPTY, QUEUE_REMOVE, uv__handle_stop, and uv_signal_stop().

Referenced by uv_close().

uv__process_close_stream()

static void uv__process_close_stream ( uv_stdio_container_t *  container )

static

Definition at line 242 of file process.c.

                                                                      {
  if (!(container->flags & UV_CREATE_PIPE)) return;
  uv__stream_close(container->data.stream);
}

References uv_stdio_container_s::data, uv_stdio_container_s::flags, uv_stdio_container_s::stream, uv__stream_close(), and UV_CREATE_PIPE.

Referenced by uv_spawn().

uv__process_init_stdio()

static int uv__process_init_stdio ( uv_stdio_container_t *  container, int  fds[2]  )

static

Definition at line 180 of file process.c.

                                                                               {
  int mask;
  int fd;
 
  mask = UV_IGNORE | UV_CREATE_PIPE | UV_INHERIT_FD | UV_INHERIT_STREAM;
 
  switch (container->flags & mask) {
  case UV_IGNORE:
    return 0;
 
  case UV_CREATE_PIPE:
    assert(container->data.stream != NULL);
    if (container->data.stream->type != UV_NAMED_PIPE)
      return UV_EINVAL;
    else
      return uv__make_socketpair(fds);
 
  case UV_INHERIT_FD:
  case UV_INHERIT_STREAM:
    if (container->flags & UV_INHERIT_FD)
      fd = container->data.fd;
    else
      fd = uv__stream_fd(container->data.stream);
 
    if (fd == -1)
      return UV_EINVAL;
 
    fds[1] = fd;
    return 0;
 
  default:
    assert(0 && "Unexpected flags");
    return UV_EINVAL;
  }
}

References assert(), uv_stdio_container_s::data, fd, uv_stdio_container_s::fd, uv_stdio_container_s::flags, mask, NULL, uv_stdio_container_s::stream, uv__make_socketpair(), uv__stream_fd, UV_CREATE_PIPE, UV_IGNORE, UV_INHERIT_FD, and UV_INHERIT_STREAM.

Referenced by uv_spawn().

uv__process_open_stream()

static int uv__process_open_stream ( uv_stdio_container_t *  container, int  pipefds[2]  )

static

Definition at line 217 of file process.c.

                                                   {
  int flags;
  int err;
 
  if (!(container->flags & UV_CREATE_PIPE) || pipefds[0] < 0)
    return 0;
 
  err = uv__close(pipefds[1]);
  if (err != 0)
    abort();
 
  pipefds[1] = -1;
  uv__nonblock(pipefds[0], 1);
 
  flags = 0;
  if (container->flags & UV_WRITABLE_PIPE)
    flags |= UV_HANDLE_READABLE;
  if (container->flags & UV_READABLE_PIPE)
    flags |= UV_HANDLE_WRITABLE;
 
  return uv__stream_open(container->data.stream, pipefds[0], flags);
}

References uv_stdio_container_s::data, err, flags, uv_stdio_container_s::flags, uv_stdio_container_s::stream, uv__close(), uv__nonblock, uv__stream_open(), UV_CREATE_PIPE, UV_HANDLE_READABLE, UV_HANDLE_WRITABLE, UV_READABLE_PIPE, and UV_WRITABLE_PIPE.

Referenced by uv_spawn().

uv__write_int()

static void uv__write_int ( int  fd, int  val  )

static

Definition at line 248 of file process.c.

                                           {
  ssize_t n;
 
  do
    n = write(fd, &val, sizeof(val));
  while (n == -1 && errno == EINTR);
 
  if (n == -1 && errno == EPIPE)
    return; /* parent process has quit */
 
  assert(n == sizeof(val));
}

References assert(), EINTR, EPIPE, fd, n, val, and write.

Referenced by uv__process_child_init().

uv_kill()

int uv_kill	(	int	pid,
		int	signum
	)

Definition at line 582 of file process.c.

                                 {
  if (kill(pid, signum))
    return UV__ERR(errno);
  else
    return 0;
}

Referenced by uv_process_kill().

uv_process_kill()

int uv_process_kill	(	uv_process_t *	process,
		int	signum
	)

Definition at line 577 of file process.c.

                                                       {
  return uv_kill(process->pid, signum);
}

uv_spawn()

int uv_spawn	(	uv_loop_t *	loop,
		uv_process_t *	process,
		const uv_process_options_t *	options
	)

Definition at line 408 of file process.c.

                                                  {
#if defined(__APPLE__) && (TARGET_OS_TV || TARGET_OS_WATCH)
  /* fork is marked __WATCHOS_PROHIBITED __TVOS_PROHIBITED. */
  return UV_ENOSYS;
#else
  int signal_pipe[2] = { -1, -1 };
  int pipes_storage[8][2];
  int (*pipes)[2];
  int stdio_count;
  ssize_t r;
  pid_t pid;
  int err;
  int exec_errorno;
  int i;
  int status;
 
  assert(options->file != NULL);
  assert(!(options->flags & ~(UV_PROCESS_DETACHED |
                              UV_PROCESS_SETGID |
                              UV_PROCESS_SETUID |
                              UV_PROCESS_WINDOWS_HIDE |
                              UV_PROCESS_WINDOWS_HIDE_CONSOLE |
                              UV_PROCESS_WINDOWS_HIDE_GUI |
                              UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS)));
 
  uv__handle_init(loop, (uv_handle_t*)process, UV_PROCESS);
  QUEUE_INIT(&process->queue);
 
  stdio_count = options->stdio_count;
  if (stdio_count < 3)
    stdio_count = 3;
 
  err = UV_ENOMEM;
  pipes = pipes_storage;
  if (stdio_count > (int) ARRAY_SIZE(pipes_storage))
    pipes = uv__malloc(stdio_count * sizeof(*pipes));
 
  if (pipes == NULL)
    goto error;
 
  for (i = 0; i < stdio_count; i++) {
    pipes[i][0] = -1;
    pipes[i][1] = -1;
  }
 
  for (i = 0; i < options->stdio_count; i++) {
    err = uv__process_init_stdio(options->stdio + i, pipes[i]);
    if (err)
      goto error;
  }
 
  /* This pipe is used by the parent to wait until
   * the child has called `execve()`. We need this
   * to avoid the following race condition:
   *
   *    if ((pid = fork()) > 0) {
   *      kill(pid, SIGTERM);
   *    }
   *    else if (pid == 0) {
   *      execve("/bin/cat", argp, envp);
   *    }
   *
   * The parent sends a signal immediately after forking.
   * Since the child may not have called `execve()` yet,
   * there is no telling what process receives the signal,
   * our fork or /bin/cat.
   *
   * To avoid ambiguity, we create a pipe with both ends
   * marked close-on-exec. Then, after the call to `fork()`,
   * the parent polls the read end until it EOFs or errors with EPIPE.
   */
  err = uv__make_pipe(signal_pipe, 0);
  if (err)
    goto error;
 
  uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD);
 
  /* Acquire write lock to prevent opening new fds in worker threads */
  uv_rwlock_wrlock(&loop->cloexec_lock);
  pid = fork();
 
  if (pid == -1) {
    err = UV__ERR(errno);
    uv_rwlock_wrunlock(&loop->cloexec_lock);
    uv__close(signal_pipe[0]);
    uv__close(signal_pipe[1]);
    goto error;
  }
 
  if (pid == 0) {
    uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]);
    abort();
  }
 
  /* Release lock in parent process */
  uv_rwlock_wrunlock(&loop->cloexec_lock);
  uv__close(signal_pipe[1]);
 
  process->status = 0;
  exec_errorno = 0;
  do
    r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno));
  while (r == -1 && errno == EINTR);
 
  if (r == 0)
    ; /* okay, EOF */
  else if (r == sizeof(exec_errorno)) {
    do
      err = waitpid(pid, &status, 0); /* okay, read errorno */
    while (err == -1 && errno == EINTR);
    assert(err == pid);
  } else if (r == -1 && errno == EPIPE) {
    do
      err = waitpid(pid, &status, 0); /* okay, got EPIPE */
    while (err == -1 && errno == EINTR);
    assert(err == pid);
  } else
    abort();
 
  uv__close_nocheckstdio(signal_pipe[0]);
 
  for (i = 0; i < options->stdio_count; i++) {
    err = uv__process_open_stream(options->stdio + i, pipes[i]);
    if (err == 0)
      continue;
 
    while (i--)
      uv__process_close_stream(options->stdio + i);
 
    goto error;
  }
 
  /* Only activate this handle if exec() happened successfully */
  if (exec_errorno == 0) {
    QUEUE_INSERT_TAIL(&loop->process_handles, &process->queue);
    uv__handle_start(process);
  }
 
  process->pid = pid;
  process->exit_cb = options->exit_cb;
 
  if (pipes != pipes_storage)
    uv__free(pipes);
 
  return exec_errorno;
 
error:
  if (pipes != NULL) {
    for (i = 0; i < stdio_count; i++) {
      if (i < options->stdio_count)
        if (options->stdio[i].flags & (UV_INHERIT_FD | UV_INHERIT_STREAM))
          continue;
      if (pipes[i][0] != -1)
        uv__close_nocheckstdio(pipes[i][0]);
      if (pipes[i][1] != -1)
        uv__close_nocheckstdio(pipes[i][1]);
    }
 
    if (pipes != pipes_storage)
      uv__free(pipes);
  }
 
  return err;
#endif
}

Variable Documentation

environ

char** environ

extern

Referenced by uv__process_child_init().