Function sigwait_thread_function

b/b.cxx:279–339

static sigset_t sigwait_mask;

static void*
sigwait_thread_function (void* d)
{
  int sig;
  if (int e = sigwait (&sigwait_mask, &sig))
  {
    cerr << "error: unable to wait for signals: "
         << system_error (e, generic_category ()) // Sanitize.
         << endl;

    terminate (false /* trace */);
  }

  if (sig == SIGUSR1) // Request to shutdown.
    return nullptr;

  // Block all the threads that attempt to issue any diagnostics.
  //
  // Note that the primary goal here is to suppress diagnostics about
  // abnormally terminated child processes, which could have been terminated
  // due to a signal sent to the whole process group (see
  // butl::process::wait() implementation for details on the issue we try to
  // resolve). The blocked threads will stay as such until the process is
  // terminated.
  //
  // Also note that there is still a possibility that after sigwait() returns,
  // making the signal non-pending, and before the diagnostics mutex is
  // locked, some threads may print the diagnostics we try to avoid. If it
  // ever becomes a problem, we can consider using the Linux and FreeBSD
  // specific signalfd() in combination with select() and read(), which seems
  // to provide an ability to make the transition from the pending signal to
  // the locked diagnostics mutex atomic.
  //
  diag_stream_lock dl;

  // Instruct the scheduler to pre-shutdown (stop executing new tasks, etc).
  //
  build2::scheduler& s (*static_cast<build2::scheduler*> (d));
  s.shutdown (false /* wait */);

  // Unblock the signal, so that it can be raised.
  //
  sigset_t um;
  sigemptyset (&um);
  sigaddset (&um, sig);

  if (int e = pthread_sigmask (SIG_UNBLOCK, &um, nullptr /* oldset */))
  {
    cerr << "error: unable to unblock signal " << sig << ": "
         << system_error (e, generic_category ()) // Sanitize.
         << endl;

    terminate (false /* trace */);
  }

  // Call the signal handler.
  //
  build2_b_cleanup_handler (sig);