process_util.c

// SPDX-License-Identifier: Apache-2.0

#include "config.h"

#include "process_util.h"

#include <errno.h>
#include <stdbool.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include <unistd.h>

#include "build-config.h"
#include "io_util.h"
#include "logging.h"
#include "time_util.h"
#include "xsl_signal.h"

static char *const *BorrowExecvArgv(const char *const argv[]) {
  char *const *execv_argv = NULL;
  memcpy((void *)&execv_argv, (const void *)&argv, sizeof(execv_argv));
  return execv_argv;
}

static int ExecvHelper(const char *path, const char *const argv[]);
static void ExecvHelperOrExit(const char *path, const char *const argv[]);

pid_t ForkWithoutSigHandlers(void) {
  sigset_t oldset;
  sigset_t set;
  sigemptyset(&set);
  sigaddset(&set, SIGUSR1);
  sigaddset(&set, SIGUSR2);
  sigaddset(&set, SIGTERM);
  sigaddset(&set, SIGCHLD);
  sigemptyset(&oldset);
  if (sigprocmask(SIG_BLOCK, &set, &oldset)) {
    LogErrno("Unable to block signals");
  }
  pid_t pid = fork();
  int fork_errno = errno;
  if (pid == 0) {
    if (ResetSignalToDefault(SIGUSR1) != 0) {
      LogErrno("sigaction(SIGUSR1)");
    }
    if (ResetSignalToDefault(SIGUSR2) != 0) {
      LogErrno("sigaction(SIGUSR2)");
    }
    if (ResetSignalToDefault(SIGTERM) != 0) {
      LogErrno("sigaction(SIGTERM)");
    }
    if (ResetSignalToDefault(SIGCHLD) != 0) {
      LogErrno("sigaction(SIGCHLD)");
    }
  }
  if (sigprocmask(SIG_SETMASK, &oldset, NULL)) {
    LogErrno("Unable to restore signal mask");
  }
  errno = fork_errno;
  return pid;
}

void StartPgrp(void) {
  if (setsid() == (pid_t)-1) {
    LogErrno("setsid");
  }
  // To avoid a race condition when killing the process group after the leader
  // is already dead (which could then kill another new process group with the
  // same ID), keep a placeholder alive until the group is explicitly signaled.
  pid_t pid = fork();
  if (pid == -1) {
    LogErrno("StartPgrp -> fork; expect potential race in KillPgrp");
  } else if (pid == 0) {
    if (IgnoreSignal(SIGUSR1) != 0) {
      LogErrno("sigaction(SIGUSR1)");
    }
    if (IgnoreSignal(SIGUSR2) != 0) {
      LogErrno("sigaction(SIGUSR2)");
    }

    const char *args[2] = {"pgrp_placeholder", NULL};
    ExecvHelperOrExit("pgrp_placeholder", args);
  }
}

pid_t ForkHelperChild(const char *label, ChildSetupFn setup, void *setup_arg,
                      const char *path, const char *const argv[]) {
  pid_t pid = ForkWithoutSigHandlers();
  if (pid == -1) {
    LogErrno("fork for %s", label);
    return -1;
  }
  if (pid == 0) {
    if (setup != NULL) {
      setup(setup_arg);
    }
    ExecvHelperOrExit(path, argv);
  }
  return pid;
}

pid_t ForkHelperPgrpChild(const char *label, ChildSetupFn setup,
                          void *setup_arg, const char *path,
                          const char *const argv[]) {
  pid_t pid = ForkWithoutSigHandlers();
  if (pid == -1) {
    LogErrno("fork for %s", label);
    return -1;
  }
  if (pid == 0) {
    StartPgrp();
    if (setup != NULL) {
      setup(setup_arg);
    }
    ExecvHelperOrExit(path, argv);
  }
  return pid;
}

static int ExecvHelper(const char *path, const char *const argv[]) {
  if (chdir(HELPER_PATH)) {
    LogErrno("chdir %s", HELPER_PATH);
    return -1;
  }

  execv(path, BorrowExecvArgv(argv));
  int saved_errno = errno;
  LogErrno("execv %s", path);
  errno = saved_errno;
  return -1;
}

static void ExecvHelperOrExit(const char *path, const char *const argv[]) {
  ExecvHelper(path, argv);
  (void)SleepMs(2000);
  _exit(EXIT_FAILURE);
}

void ExecvpOrExit(const char *path, char *const argv[]) {
  execvp(path, argv);
  LogErrno("execvp %s", path);
  _exit(EXIT_FAILURE);
}

static void MoveStdioFdOrExit(int *fd, int target_fd) {
  if (*fd < 0) {
    return;
  }
  if (*fd <= STDERR_FILENO && *fd != target_fd) {
    *fd = DuplicateAwayFromStdio(*fd);
    if (*fd < 0) {
      LogErrno("DuplicateAwayFromStdio");
      _exit(EXIT_FAILURE);
    }
  }
  if (MoveFdTo(fd, target_fd) != 0) {
    LogErrno("MoveFdTo");
    _exit(EXIT_FAILURE);
  }
}

void ChildWireStdioOrExit(const struct ChildStdioSetup *setup) {
  struct ChildStdioSetup local = *setup;

  MoveStdioFdOrExit(&local.stdin_fd, STDIN_FILENO);
  MoveStdioFdOrExit(&local.stdout_fd, STDOUT_FILENO);
  MoveStdioFdOrExit(&local.stderr_fd, STDERR_FILENO);
}

bool WaitPidNoEintr(pid_t pid, int *status_out) {
  for (;;) {
    pid_t gotpid = waitpid(pid, status_out, 0);
    if (gotpid == pid) {
      return true;
    }
    if (gotpid < 0 && errno == EINTR) {
      continue;
    }
    return false;
  }
}

bool LogWaitStatus(const char *label, int status) {
  if (WIFSIGNALED(status)) {
    Log("%s terminated by signal %d", label, WTERMSIG(status));
    return false;
  }
  if (!WIFEXITED(status)) {
    Log("%s ended unexpectedly", label);
    return false;
  }
  if (WEXITSTATUS(status) != EXIT_SUCCESS) {
    Log("%s exited with status %d", label, WEXITSTATUS(status));
    return false;
  }
  return true;
}

void KillProcIfRunning(pid_t pid, int signo) {
  if (pid == 0) {
    return;
  }
  if (kill(pid, signo) != 0 && errno != ESRCH) {
    LogErrno("kill");
  }
}