[lldb/host] Remove monitor_signals argument from process monitoring functions

[labath]

Summary

All current callers set the argument to false. monitor_signals=true used
to be used in the Process plugins (which needed to know when the
debugged process gets a signal), but this implementation has several
serious issues, which means that individual process plugins now
orchestrate the monitoring of debugged processes themselves.

This allows us to simplify the implementation (no need to play with
process groups), and the interface (we only catch fatal events, so the
callback is always called just once).

[JDevlieghere]

Nice

[thakis]

Breaks Mac build: http://45.33.8.238/macm1/28811/step_4.txt

Ptal.

lldb/include/lldb/Host/Host.h

 inline bool operator!=(WaitStatus a, WaitStatus b) { return !(a == b); }
 
 /// \class Host Host.h "lldb/Host/Host.h"
 /// A class that provides host computer information.
 ///
 /// Host is a class that answers information about the host operating system.
 class Host {
 public:
-  typedef std::function<bool(
-      lldb::pid_t pid, bool exited,
+  typedef std::function<void(lldb::pid_t pid,
                              int signal,  // Zero for no signal
-      int status)> // Exit value of process if signal is zero
+                             int status)> // Exit value of process if signal is
+                                          // zero
       MonitorChildProcessCallback;
 
   /// Start monitoring a child process.
   ///
   /// Allows easy monitoring of child processes. \a callback will be called
-  /// when the child process exits or if it gets a signal. The callback will
-  /// only be called with signals if \a monitor_signals is \b true. \a
-  /// callback will usually be called from another thread so the callback
-  /// function must be thread safe.
-  ///
-  /// When the callback gets called, the return value indicates if monitoring
-  /// should stop. If \b true is returned from \a callback the information
-  /// will be removed. If \b false is returned then monitoring will continue.
-  /// If the child process exits, the monitoring will automatically stop after
-  /// the callback returned regardless of the callback return value.
+  /// when the child process exits or if it dies from a signal.
   ///
   /// \param[in] callback
   ///     A function callback to call when a child receives a signal
-  ///     (if \a monitor_signals is true) or a child exits.
+  ///     or exits.
   ///
   /// \param[in] pid
-  ///     The process ID of a child process to monitor, -1 for all
-  ///     processes.
-  ///
-  /// \param[in] monitor_signals
-  ///     If \b true the callback will get called when the child
-  ///     process gets a signal. If \b false, the callback will only
-  ///     get called if the child process exits.
+  ///     The process ID of a child process to monitor.
   ///
   /// \return
   ///     A thread handle that can be used to cancel the thread that
   ///     was spawned to monitor \a pid.
-  ///
-  /// \see static void Host::StopMonitoringChildProcess (uint32_t)
   static llvm::Expected<HostThread>
   StartMonitoringChildProcess(const MonitorChildProcessCallback &callback,
-                              lldb::pid_t pid, bool monitor_signals);
+                              lldb::pid_t pid);
 
   enum SystemLogType { eSystemLogWarning, eSystemLogError };
 
   static void SystemLog(SystemLogType type, const char *format, ...)
       __attribute__((format(printf, 2, 3)));
 
   static void SystemLog(SystemLogType type, const char *format, va_list args);
 

lldb/include/lldb/Host/HostNativeProcessBase.h

public:
   virtual Status Terminate() = 0;
 
   virtual lldb::pid_t GetProcessId() const = 0;
   virtual bool IsRunning() const = 0;
 
   lldb::process_t GetSystemHandle() const { return m_process; }
 
   virtual llvm::Expected<HostThread>
-  StartMonitoring(const Host::MonitorChildProcessCallback &callback,
-                  bool monitor_signals) = 0;
+  StartMonitoring(const Host::MonitorChildProcessCallback &callback) = 0;
 
 protected:
   lldb::process_t m_process;
 };
 }
 
 #endif

lldb/include/lldb/Host/HostProcess.h

public:
   ~HostProcess();
 
   Status Terminate();
 
   lldb::pid_t GetProcessId() const;
   bool IsRunning() const;
 
   llvm::Expected<HostThread>
-  StartMonitoring(const Host::MonitorChildProcessCallback &callback,
-                  bool monitor_signals);
+  StartMonitoring(const Host::MonitorChildProcessCallback &callback);
 
   HostNativeProcessBase &GetNativeProcess();
   const HostNativeProcessBase &GetNativeProcess() const;
 
 private:
   std::shared_ptr<HostNativeProcessBase> m_native_process;
 };
 }
 
 #endif

lldb/include/lldb/Host/ProcessLaunchInfo.h

public:
   void SetShellExpandArguments(bool expand);
 
   void Clear();
 
   bool ConvertArgumentsForLaunchingInShell(Status &error, bool will_debug,
                                            bool first_arg_is_full_shell_command,
                                            uint32_t num_resumes);
 
-  void
-  SetMonitorProcessCallback(const Host::MonitorChildProcessCallback &callback,
-                            bool monitor_signals);
+  void SetMonitorProcessCallback(Host::MonitorChildProcessCallback callback) {
+    m_monitor_callback = std::move(callback);
+  }
 
-  Host::MonitorChildProcessCallback GetMonitorProcessCallback() const {
+  const Host::MonitorChildProcessCallback &GetMonitorProcessCallback() const {
     return m_monitor_callback;
   }
 
   /// A Monitor callback which does not take any action on process events. Use
   /// this if you don't need to take any particular action when the process
   /// terminates, but you still need to reap it.
-  static bool NoOpMonitorCallback(lldb::pid_t pid, bool exited, int signal,
-                                  int status);
-
-  bool GetMonitorSignals() const { return m_monitor_signals; }
+  static void NoOpMonitorCallback(lldb::pid_t pid, int signal, int status);
 
   // If the LaunchInfo has a monitor callback, then arrange to monitor the
   // process. Return true if the LaunchInfo has taken care of monitoring the
   // process, and false if the caller might want to monitor the process
   // themselves.
 
   bool MonitorProcess() const;
 
protected:
   FileSpec m_working_dir;
   std::string m_plugin_name;
   FileSpec m_shell;
   Flags m_flags; // Bitwise OR of bits from lldb::LaunchFlags
   std::vector<FileAction> m_file_actions; // File actions for any other files
   std::shared_ptr<PseudoTerminal> m_pty;
   uint32_t m_resume_count = 0; // How many times do we resume after launching
   Host::MonitorChildProcessCallback m_monitor_callback;
-  void *m_monitor_callback_baton = nullptr;
-  bool m_monitor_signals = false;
   std::string m_event_data; // A string passed to the plugin launch, having no
                             // meaning to the upper levels of lldb.
   lldb::ListenerSP m_listener_sp;
   lldb::ListenerSP m_hijack_listener_sp;
   std::string m_scripted_process_class_name; // The name of the class that will
                                              // manage a scripted process.
   StructuredData::DictionarySP
       m_scripted_process_dictionary_sp; // A dictionary that holds key/value
                                         // pairs passed to the scripted process.
 };
 }
 
 #endif // LLDB_HOST_PROCESSLAUNCHINFO_H

lldb/include/lldb/Host/posix/HostProcessPosix.h

public:
   static Status Signal(lldb::process_t process, int signo);
 
   Status Terminate() override;
 
   lldb::pid_t GetProcessId() const override;
   bool IsRunning() const override;
 
   llvm::Expected<HostThread>
-  StartMonitoring(const Host::MonitorChildProcessCallback &callback,
-                  bool monitor_signals) override;
+  StartMonitoring(const Host::MonitorChildProcessCallback &callback) override;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_HOST_POSIX_HOSTPROCESSPOSIX_H

lldb/include/lldb/Host/windows/HostProcessWindows.h

public:
   void SetOwnsHandle(bool owns);
 
   Status Terminate() override;
 
   lldb::pid_t GetProcessId() const override;
   bool IsRunning() const override;
 
   virtual llvm::Expected<HostThread>
-  StartMonitoring(const Host::MonitorChildProcessCallback &callback,
-                  bool monitor_signals) override;
+  StartMonitoring(const Host::MonitorChildProcessCallback &callback) override;
 
 private:
   void Close();
 
   bool m_owns_handle;
 };
 }
 
 #endif

lldb/source/Host/common/Host.cpp

 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 #if !defined(__APPLE__) && !defined(_WIN32)
 static thread_result_t
 MonitorChildProcessThreadFunction(::pid_t pid,
-                                  Host::MonitorChildProcessCallback callback,
-                                  bool monitor_signals);
+                                  Host::MonitorChildProcessCallback callback);
 
 llvm::Expected<HostThread> Host::StartMonitoringChildProcess(
-    const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
-    bool monitor_signals) {
+    const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid) {
   char thread_name[256];
   ::snprintf(thread_name, sizeof(thread_name),
              "<lldb.host.wait4(pid=%" PRIu64 ")>", pid);
   assert(pid <= UINT32_MAX);
-  return ThreadLauncher::LaunchThread(thread_name, [pid, callback,
-                                                    monitor_signals] {
-    return MonitorChildProcessThreadFunction(pid, callback, monitor_signals);
+  return ThreadLauncher::LaunchThread(thread_name, [pid, callback] {
+    return MonitorChildProcessThreadFunction(pid, callback);
   });
 }
 
 #ifndef __linux__
 // Scoped class that will disable thread canceling when it is constructed, and
 // exception safely restore the previous value it when it goes out of scope.
 class ScopedPThreadCancelDisabler {
 public:

 #else
   ::pthread_testcancel();
 #endif
   return false;
 }
 
 static thread_result_t
 MonitorChildProcessThreadFunction(::pid_t pid,
-                                  Host::MonitorChildProcessCallback callback,
-                                  bool monitor_signals) {
+                                  Host::MonitorChildProcessCallback callback) {
   Log *log = GetLog(LLDBLog::Process);
-  LLDB_LOG(log, "pid = {0}, monitor_signals = {1}", pid, monitor_signals);
-
-  pid = monitor_signals ? -1 * getpgid(pid) : pid;
+  LLDB_LOG(log, "pid = {0}", pid);
 
   int status = -1;
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__)
-#define __WALL 0
-#endif
-  const int options = __WALL;
 
 #ifdef __linux__
   // This signal is only used to interrupt the thread from waitpid
   struct sigaction sigUsr1Action;
   memset(&sigUsr1Action, 0, sizeof(sigUsr1Action));
   sigUsr1Action.sa_handler = SigUsr1Handler;
   ::sigaction(SIGUSR1, &sigUsr1Action, nullptr);
 #endif // __linux__
 
-  while (true) {
+  while(1) {
     log = GetLog(LLDBLog::Process);
-    LLDB_LOG(log, "::waitpid({0}, &status, {1})...", pid, options);
+    LLDB_LOG(log, "::waitpid({0}, &status, 0)...", pid);
 
     if (CheckForMonitorCancellation())
-      break;
+      return nullptr;
+
+    const ::pid_t wait_pid = ::waitpid(pid, &status, 0);
 
-    // Get signals from all children with same process group of pid
-    const ::pid_t wait_pid = ::waitpid(pid, &status, options);
+    LLDB_LOG(log, "::waitpid({0}, &status, 0) => pid = {1}, status = {2:x}", pid,
+             wait_pid, status);
 
     if (CheckForMonitorCancellation())
-      break;
+      return nullptr;
 
-    if (wait_pid == -1) {
-      if (errno == EINTR)
-        continue;
-      else {
-        LLDB_LOG(log,
-                 "pid = {0}, thread exiting because waitpid failed ({1})...",
-                 pid, llvm::sys::StrError());
-        break;
-      }
-    } else if (wait_pid > 0) {
-      bool exited = false;
-      int signal = 0;
-      int exit_status = 0;
-      const char *status_cstr = nullptr;
-      if (WIFSTOPPED(status)) {
-        signal = WSTOPSIG(status);
-        status_cstr = "STOPPED";
-      } else if (WIFEXITED(status)) {
-        exit_status = WEXITSTATUS(status);
-        status_cstr = "EXITED";
-        exited = true;
-      } else if (WIFSIGNALED(status)) {
-        signal = WTERMSIG(status);
-        status_cstr = "SIGNALED";
-        if (wait_pid == abs(pid)) {
-          exited = true;
-          exit_status = -1;
-        }
-      } else {
-        status_cstr = "(\?\?\?)";
-      }
+    if (wait_pid != -1)
+    if (errno != EINTR) {
+      LLDB_LOG(log, "pid = {0}, thread exiting because waitpid failed ({1})...",
+               pid, llvm::sys::StrError());
+      return nullptr;
+    }
+
+  if (WIFEXITED(status)) {
+    llvm_unreachable("Unknown status");
 
-      // Scope for pthread_cancel_disabler
-      {
 #ifndef __linux__
-        ScopedPThreadCancelDisabler pthread_cancel_disabler;
 #endif
 
-        log = GetLog(LLDBLog::Process);
-        LLDB_LOG(log,
-                 "::waitpid({0}, &status, {1}) => pid = {2}, status = {3:x} "
-                 "({4}), signal = {5}, exit_state = {6}",
-                 pid, options, wait_pid, status, status_cstr, signal,
-                 exit_status);
-
-        if (exited || (signal != 0 && monitor_signals)) {
-          bool callback_return = false;
-          if (callback)
-            callback_return = callback(wait_pid, exited, signal, exit_status);
-
-          // If our process exited, then this thread should exit
-          if (exited && wait_pid == abs(pid)) {
-            LLDB_LOG(
-                log,
-                "pid = {0} thread exiting because pid received exit signal...",
-                pid);
-            break;
-          }
-          // If the callback returns true, it means this process should exit
-          if (callback_return) {
-            LLDB_LOG(
-                log,
-                "pid = {0} thread exiting because callback returned true...",
-                pid);
-            break;
-          }
-        }
-      }
-    }
+      callback(pid, signal, exit_status);
   }
 
   LLDB_LOG(GetLog(LLDBLog::Process), "pid = {0} thread exiting...", pid);
   return nullptr;
 }
 
 #endif // #if !defined (__APPLE__) && !defined (_WIN32)
 
struct ShellInfo {
   ShellInfo() : process_reaped(false) {}
 
   lldb_private::Predicate<bool> process_reaped;
   lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
   int signo = -1;
   int status = -1;
 };
 
-static bool
+static void
 MonitorShellCommand(std::shared_ptr<ShellInfo> shell_info, lldb::pid_t pid,
-                    bool exited, // True if the process did exit
-                    int signo,   // Zero for no signal
-                    int status)  // Exit value of process if signal is zero
+                    int signo,  // Zero for no signal
+                    int status) // Exit value of process if signal is zero
 {
   shell_info->pid = pid;
   shell_info->signo = signo;
   shell_info->status = status;
   // Let the thread running Host::RunShellCommand() know that the process
   // exited and that ShellInfo has been filled in by broadcasting to it
   shell_info->process_reaped.SetValue(true, eBroadcastAlways);
-  return true;
 }
 
 Status Host::RunShellCommand(llvm::StringRef command,
                              const FileSpec &working_dir, int *status_ptr,
                              int *signo_ptr, std::string *command_output_ptr,
                              const Timeout<std::micro> &timeout,
                              bool run_in_shell, bool hide_stderr) {
   return RunShellCommand(llvm::StringRef(), Args(command), working_dir,
else
     launch_info.AppendSuppressFileAction(STDOUT_FILENO, false, true);
 
   if (output_file_spec && !hide_stderr)
     launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
   else
     launch_info.AppendSuppressFileAction(STDERR_FILENO, false, true);
 
   std::shared_ptr<ShellInfo> shell_info_sp(new ShellInfo());
-  const bool monitor_signals = false;
   launch_info.SetMonitorProcessCallback(
       std::bind(MonitorShellCommand, shell_info_sp, std::placeholders::_1,
-                std::placeholders::_2, std::placeholders::_3,
-                std::placeholders::_4),
-      monitor_signals);
+                std::placeholders::_2, std::placeholders::_3));
 
   error = LaunchProcess(launch_info);
   const lldb::pid_t pid = launch_info.GetProcessID();
 
   if (error.Success() && pid == LLDB_INVALID_PROCESS_ID)
     error.SetErrorString("failed to get process ID");
 
   if (error.Success()) {

lldb/source/Host/common/HostProcess.cpp

 Status HostProcess::Terminate() { return m_native_process->Terminate(); }
 
 lldb::pid_t HostProcess::GetProcessId() const {
   return m_native_process->GetProcessId();
 }
 
 bool HostProcess::IsRunning() const { return m_native_process->IsRunning(); }
 
-llvm::Expected<HostThread>
-HostProcess::StartMonitoring(const Host::MonitorChildProcessCallback &callback,
-                             bool monitor_signals) {
-  return m_native_process->StartMonitoring(callback, monitor_signals);
+llvm::Expected<HostThread> HostProcess::StartMonitoring(
+    const Host::MonitorChildProcessCallback &callback) {
+  return m_native_process->StartMonitoring(callback);
 }
 
 HostNativeProcessBase &HostProcess::GetNativeProcess() {
   return *m_native_process;
 }
 
 const HostNativeProcessBase &HostProcess::GetNativeProcess() const {
   return *m_native_process;
 }

lldb/source/Host/common/MonitoringProcessLauncher.cpp

MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info,
   HostProcess process =
       m_delegate_launcher->LaunchProcess(resolved_info, error);
 
   if (process.GetProcessId() != LLDB_INVALID_PROCESS_ID) {
     Log *log = GetLog(LLDBLog::Process);
 
     assert(launch_info.GetMonitorProcessCallback());
     llvm::Expected<HostThread> maybe_thread =
-        process.StartMonitoring(launch_info.GetMonitorProcessCallback(),
-                                launch_info.GetMonitorSignals());
+        process.StartMonitoring(launch_info.GetMonitorProcessCallback());
     if (!maybe_thread)
       error.SetErrorStringWithFormatv("failed to launch host thread: {}",
                                       llvm::toString(maybe_thread.takeError()));
     if (log)
       log->PutCString("started monitoring child process.");
   } else {
     // Invalid process ID, something didn't go well
     if (error.Success())
       error.SetErrorString("process launch failed for unknown reasons");
   }
   return process;
 }

lldb/source/Host/common/ProcessLaunchInfo.cpp

 
 ProcessLaunchInfo::ProcessLaunchInfo(const FileSpec &stdin_file_spec,
                                      const FileSpec &stdout_file_spec,
                                      const FileSpec &stderr_file_spec,
                                      const FileSpec &working_directory,
                                      uint32_t launch_flags)
     : ProcessInfo(), m_working_dir(), m_plugin_name(), m_flags(launch_flags),
       m_file_actions(), m_pty(new PseudoTerminal), m_resume_count(0),
-      m_monitor_callback(nullptr), m_monitor_callback_baton(nullptr),
-      m_monitor_signals(false), m_listener_sp(), m_hijack_listener_sp(),
       m_scripted_process_class_name(), m_scripted_process_dictionary_sp() {
   if (stdin_file_spec) {
     FileAction file_action;
     const bool read = true;
     const bool write = false;
     if (file_action.Open(STDIN_FILENO, stdin_file_spec, read, write))
       AppendFileAction(file_action);
   }
void ProcessLaunchInfo::Clear() {
   m_file_actions.clear();
   m_resume_count = 0;
   m_listener_sp.reset();
   m_hijack_listener_sp.reset();
   m_scripted_process_class_name.clear();
   m_scripted_process_dictionary_sp.reset();
 }
 
-void ProcessLaunchInfo::SetMonitorProcessCallback(
-    const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
-  m_monitor_callback = callback;
-  m_monitor_signals = monitor_signals;
-}
-
-bool ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, bool exited, int signal, int status) {
+void ProcessLaunchInfo::NoOpMonitorCallback(lldb::pid_t pid, int signal,
+                                            int status) {
   Log *log = GetLog(LLDBLog::Process);
-  LLDB_LOG(log, "pid = {0}, exited = {1}, signal = {2}, status = {3}", pid,
-           exited, signal, status);
-  return true;
+  LLDB_LOG(log, "pid = {0}, signal = {1}, status = {2}", pid, signal, status);
 }
 
 bool ProcessLaunchInfo::MonitorProcess() const {
   if (m_monitor_callback && ProcessIDIsValid()) {
     llvm::Expected<HostThread> maybe_thread =
-    Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID(),
-                                      m_monitor_signals);
+        Host::StartMonitoringChildProcess(m_monitor_callback, GetProcessID());
     if (!maybe_thread)
       LLDB_LOG(GetLog(LLDBLog::Host), "failed to launch host thread: {}",
                llvm::toString(maybe_thread.takeError()));
     return true;
   }
   return false;
 }
 

lldb/source/Host/macosx/objcxx/Host.mm

for (size_t i = 0; i < args_array_sp->GetSize(); i++) {
       launch_info.GetArguments().AppendArgument(str_sp->GetValue());
     }
   }
 
   return error;
 }
 
 llvm::Expected<HostThread> Host::StartMonitoringChildProcess(
-    const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
-    bool monitor_signals) {
+    const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid) {
   unsigned long mask = DISPATCH_PROC_EXIT;
-  if (monitor_signals)
-    mask |= DISPATCH_PROC_SIGNAL;
 
   Log *log(GetLog(LLDBLog::Host | LLDBLog::Process));
 
   dispatch_source_t source = ::dispatch_source_create(
       DISPATCH_SOURCE_TYPE_PROC, pid, mask,
       ::dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
 
   LLDB_LOGF(log,
-            "Host::StartMonitoringChildProcess "
-            "(callback, pid=%i, monitor_signals=%i) "
-            "source = %p\n",
-            static_cast<int>(pid), monitor_signals,
-            static_cast<void *>(source));
+            "Host::StartMonitoringChildProcess(callback, pid=%i) source = %p\n",
+            static_cast<int>(pid), static_cast<void *>(source));
 
   if (source) {
     Host::MonitorChildProcessCallback callback_copy = callback;
     ::dispatch_source_set_cancel_handler(source, ^{
       dispatch_release(source);
     });
     ::dispatch_source_set_event_handler(source, ^{
 
       int status = 0;
       int wait_pid = 0;
-      bool cancel = false;
-      bool exited = false;
       wait_pid = llvm::sys::RetryAfterSignal(-1, ::waitpid, pid, &status, 0);
       if (wait_pid >= 0) {
         int signal = 0;
         int exit_status = 0;
         const char *status_cstr = NULL;
-        if (WIFSTOPPED(status)) {
-          signal = WSTOPSIG(status);
-          status_cstr = "STOPPED";
-        } else if (WIFEXITED(status)) {
+        if (WIFEXITED(status)) {
           exit_status = WEXITSTATUS(status);
           status_cstr = "EXITED";
-          exited = true;
         } else if (WIFSIGNALED(status)) {
           signal = WTERMSIG(status);
           status_cstr = "SIGNALED";
-          exited = true;
           exit_status = -1;
         } else {
-          status_cstr = "???";
+          llvm_unreachable("Unknown status");
         }
 
         LLDB_LOGF(log,
                   "::waitpid (pid = %llu, &status, 0) => pid = %i, status "
                   "= 0x%8.8x (%s), signal = %i, exit_status = %i",
                   pid, wait_pid, status, status_cstr, signal, exit_status);
 
         if (callback_copy)
-          cancel = callback_copy(pid, exited, signal, exit_status);
+          callback_copy(pid, signal, exit_status);
 
-        if (exited || cancel) {
-          ::dispatch_source_cancel(source);
         }
       }
     });
 
     ::dispatch_resume(source);
   }
   return HostThread();
 }

lldb/source/Host/posix/HostProcessPosix.cpp

if (m_process == kInvalidPosixProcess)
     return false;
 
   // Send this process the null signal.  If it succeeds the process is running.
   Status error = Signal(0);
   return error.Success();
 }
 
 llvm::Expected<HostThread> HostProcessPosix::StartMonitoring(
-    const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
-  return Host::StartMonitoringChildProcess(callback, m_process,
-                                           monitor_signals);
+    const Host::MonitorChildProcessCallback &callback) {
+  return Host::StartMonitoringChildProcess(callback, m_process);
 }

lldb/source/Host/windows/HostProcessWindows.cpp

MonitorThread(const Host::MonitorChildProcessCallback &callback,
   ::WaitForSingleObject(process_handle, INFINITE);
   ::GetExitCodeProcess(process_handle, &exit_code);
   callback(::GetProcessId(process_handle), true, 0, exit_code);
   ::CloseHandle(process_handle);
   return {};
 }
 
 llvm::Expected<HostThread> HostProcessWindows::StartMonitoring(
-    const Host::MonitorChildProcessCallback &callback, bool monitor_signals) {
+    const Host::MonitorChildProcessCallback &callback) {
   HANDLE process_handle;
 
   // Since the life of this HostProcessWindows instance and the life of the
   // process may be different, duplicate the handle so that the monitor thread
   // can have ownership over its own copy of the handle.
   if (::DuplicateHandle(GetCurrentProcess(), m_process, GetCurrentProcess(),
                         &process_handle, 0, FALSE, DUPLICATE_SAME_ACCESS)) {
     return ThreadLauncher::LaunchThread(

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

lldb::ProcessSP PlatformDarwin::DebugProcess(ProcessLaunchInfo &launch_info,
                                              Status &error) {
   ProcessSP process_sp;
 
   if (IsHost()) {
     // We are going to hand this process off to debugserver which will be in
     // charge of setting the exit status.  However, we still need to reap it
     // from lldb. So, make sure we use a exit callback which does not set exit
     // status.
-    const bool monitor_signals = false;
     launch_info.SetMonitorProcessCallback(
-        &ProcessLaunchInfo::NoOpMonitorCallback, monitor_signals);
+        &ProcessLaunchInfo::NoOpMonitorCallback);
     process_sp = Platform::DebugProcess(launch_info, debugger, target, error);
   } else {
     if (m_remote_platform_sp)
       process_sp = m_remote_platform_sp->DebugProcess(launch_info, debugger,
                                                       target, error);
     else
       error.SetErrorString("the platform is not currently connected");
   }

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.cpp

if (ConstString sysroot = GetSDKRootDirectory())
     emulator_env["QEMU_LD_PREFIX"] = sysroot.GetStringRef().str();
   for (const auto &KV : GetGlobalProperties().GetEmulatorEnvVars())
     emulator_env[KV.first()] = KV.second;
   launch_info.GetEnvironment() = ComputeLaunchEnvironment(
       std::move(launch_info.GetEnvironment()), std::move(emulator_env));
 
   launch_info.SetLaunchInSeparateProcessGroup(true);
   launch_info.GetFlags().Clear(eLaunchFlagDebug);
-  launch_info.SetMonitorProcessCallback(ProcessLaunchInfo::NoOpMonitorCallback,
-                                        false);
+  launch_info.SetMonitorProcessCallback(ProcessLaunchInfo::NoOpMonitorCallback);
 
   // This is automatically done for host platform in
   // Target::FinalizeFileActions, but we're not a host platform.
   llvm::Error Err = launch_info.SetUpPtyRedirection();
   LLDB_LOG_ERROR(log, std::move(Err), "SetUpPtyRedirection failed: {0}");
 
   error = Host::LaunchProcess(launch_info);
   if (error.Fail())

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

protected:
 
   PacketResult Handle_qC(StringExtractorGDBRemote &packet);
 
   PacketResult Handle_jSignalsInfo(StringExtractorGDBRemote &packet);
 
 private:
   bool KillSpawnedProcess(lldb::pid_t pid);
 
-  bool DebugserverProcessReaped(lldb::pid_t pid);
+  void DebugserverProcessReaped(lldb::pid_t pid);
 
   static const FileSpec &GetDomainSocketDir();
 
   static FileSpec GetDomainSocketPath(const char *prefix);
 
   GDBRemoteCommunicationServerPlatform(
       const GDBRemoteCommunicationServerPlatform &) = delete;
   const GDBRemoteCommunicationServerPlatform &
   operator=(const GDBRemoteCommunicationServerPlatform &) = delete;
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERPLATFORM_H

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

Status GDBRemoteCommunicationServerPlatform::LaunchGDBServer(
   LLDB_LOGF(log, "Launching debugserver with: %s:%u...", hostname.c_str(),
             *port);
 
   // Do not run in a new session so that it can not linger after the platform
   // closes.
   debugserver_launch_info.SetLaunchInSeparateProcessGroup(false);
   debugserver_launch_info.SetMonitorProcessCallback(
       std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped,
-                this, std::placeholders::_1),
-      false);
+                this, std::placeholders::_1));
 
   std::ostringstream url;
 // debugserver does not accept the URL scheme prefix.
 #if !defined(__APPLE__)
   url << m_socket_scheme << "://";
 #endif
   uint16_t *port_ptr = port.getPointer();
   if (m_socket_protocol == Socket::ProtocolTcp) {
for (auto signo = signals->GetFirstSignalNumber();
     signal_array.Push(dictionary);
   }
 
   StreamString response;
   signal_array.Dump(response);
   return SendPacketNoLock(response.GetString());
 }
 
-bool GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped(
+void GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped(
     lldb::pid_t pid) {
   std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
   m_port_map.FreePortForProcess(pid);
   m_spawned_pids.erase(pid);
-  return true;
 }
 
 Status GDBRemoteCommunicationServerPlatform::LaunchProcess() {
   if (!m_process_launch_info.GetArguments().GetArgumentCount())
     return Status("%s: no process command line specified to launch",
                   __FUNCTION__);
 
   // specify the process monitor if not already set.  This should generally be
   // what happens since we need to reap started processes.
   if (!m_process_launch_info.GetMonitorProcessCallback())
-    m_process_launch_info.SetMonitorProcessCallback(
-        std::bind(
-            &GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped,
-            this, std::placeholders::_1),
-        false);
+    m_process_launch_info.SetMonitorProcessCallback(std::bind(
+        &GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this,
+        std::placeholders::_1));
 
   Status error = Host::LaunchProcess(m_process_launch_info);
   if (!error.Success()) {
     fprintf(stderr, "%s: failed to launch executable %s", __FUNCTION__,
             m_process_launch_info.GetArguments().GetArgumentAtIndex(0));
     return error;
   }
 

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
   size_t UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value);
 
   bool StartAsyncThread();
 
   void StopAsyncThread();
 
   lldb::thread_result_t AsyncThread();
 
-  static bool
+  static void
   MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp,
-                            lldb::pid_t pid, bool exited, int signo,
-                            int exit_status);
+                            lldb::pid_t pid, int signo, int exit_status);
 
   lldb::StateType SetThreadStopInfo(StringExtractor &stop_packet);
 
   bool
   GetThreadStopInfoFromJSON(ThreadGDBRemote *thread,
                             const StructuredData::ObjectSP &thread_infos_sp);
 
   lldb::ThreadSP SetThreadStopInfo(StructuredData::Dictionary *thread_dict);

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID) {
     ProcessLaunchInfo debugserver_launch_info;
     // Make debugserver run in its own session so signals generated by special
     // terminal key sequences (^C) don't affect debugserver.
     debugserver_launch_info.SetLaunchInSeparateProcessGroup(true);
 
     const std::weak_ptr<ProcessGDBRemote> this_wp =
         std::static_pointer_cast<ProcessGDBRemote>(shared_from_this());
     debugserver_launch_info.SetMonitorProcessCallback(
-        std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3, _4), false);
+        std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3));
     debugserver_launch_info.SetUserID(process_info.GetUserID());
 
 #if defined(__APPLE__)
     // On macOS 11, we need to support x86_64 applications translated to
     // arm64. We check whether a binary is translated and spawn the correct
     // debugserver accordingly.
     int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
                   static_cast<int>(process_info.GetProcessID()) };
if (m_gdb_comm.IsConnected()) {
       error = ConnectToDebugserver("");
     } else {
       error.SetErrorString("connection failed");
     }
   }
   return error;
 }
 
-bool ProcessGDBRemote::MonitorDebugserverProcess(
+void ProcessGDBRemote::MonitorDebugserverProcess(
     std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
-    bool exited,    // True if the process did exit
     int signo,      // Zero for no signal
     int exit_status // Exit value of process if signal is zero
 ) {
   // "debugserver_pid" argument passed in is the process ID for debugserver
   // that we are tracking...
   Log *log = GetLog(GDBRLog::Process);
-  const bool handled = true;
 
   LLDB_LOGF(log,
             "ProcessGDBRemote::%s(process_wp, pid=%" PRIu64
             ", signo=%i (0x%x), exit_status=%i)",
             __FUNCTION__, debugserver_pid, signo, signo, exit_status);
 
   std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock();
   LLDB_LOGF(log, "ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
             static_cast<void *>(process_sp.get()));
   if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
-    return handled;
+    return;
 
   // Sleep for a half a second to make sure our inferior process has time to
   // set its exit status before we set it incorrectly when both the debugserver
   // and the inferior process shut down.
   std::this_thread::sleep_for(std::chrono::milliseconds(500));
 
   // If our process hasn't yet exited, debugserver might have died. If the
   // process did exit, then we are reaping it.
if (signo) {
                  exit_status);
     }
 
     process_sp->SetExitStatus(-1, error_str);
   }
   // Debugserver has exited we need to let our ProcessGDBRemote know that it no
   // longer has a debugserver instance
   process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
-  return handled;
 }
 
 void ProcessGDBRemote::KillDebugserverProcess() {
   m_gdb_comm.Disconnect();
   if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) {
     Host::Kill(m_debugserver_pid, SIGINT);
     m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
   }

lldb/unittests/tools/lldb-server/tests/TestClient.cpp

Expected<std::unique_ptr<TestClient>> TestClient::launchCustom(StringRef Log, ArrayRef<StringRef> ServerArgs, ArrayRef<StringRef> InferiorArgs) {
 
   ProcessLaunchInfo Info;
   Info.SetArchitecture(arch_spec);
   Info.SetArguments(args, true);
   Info.GetEnvironment() = Host::GetEnvironment();
   // TODO: Use this callback to detect botched launches. If lldb-server does not
   // start, we can print a nice error message here instead of hanging in
   // Accept().
-  Info.SetMonitorProcessCallback(&ProcessLaunchInfo::NoOpMonitorCallback,
-                                 false);
+  Info.SetMonitorProcessCallback(&ProcessLaunchInfo::NoOpMonitorCallback);
 
   status = Host::LaunchProcess(Info);
   if (status.Fail())
     return status.ToError();
 
   Socket *accept_socket;
   listen_socket.Accept(accept_socket);
   auto Conn = std::make_unique<ConnectionFileDescriptor>(accept_socket);