Generalize child process monitoring functions

[labath]

Summary

This replaces the C-style "void *" baton of the child process monitoring functions with a more
C++-like API taking a std::function. The motivation for this was that it was very difficult to
handle the ownership of the object passed into the callback function -- each caller ended up
implementing his own way of doing it, some doing it better than others. With the new API, one can
just pass a smart pointer into the callback and all of the lifetime management will be handled
automatically.

This has enabled me to simplify the rather complicated handshake in Host::RunShellCommand. I have
left handling of MonitorDebugServerProcess (my original motivation for this change) to a separate
commit to reduce the scope of this change.

[labath]

I am going to try building this on as many systems as I can get my hands on tomorrow, as I am pretty sure I have missed some changes on host-specific code. I am posting this here now, to get early feedback and some round-trips.

[labath]

In D20106#425825, @labath wrote:

I am going to try building this on as many systems as I can get my hands on tomorrow, as I am pretty sure I have missed some changes on host-specific code. I am posting this here now, to get early feedback and some round-trips.

... avoid some round-trips.

[clayborg]

Just get rid of the extra typedef as specified in inline comments and this is good to go.

include/lldb/Host/HostProcess.h

41 ↗

(On Diff #56721)

We can probably get rid of this and just use Host::MonitorChildProcessCallback

54 ↗

(On Diff #56721)

Use Host::MonitorChildProcessCallback directly.

include/lldb/Host/posix/HostProcessPosix.h

43 ↗

(On Diff #56721)

Use Host::MonitorChildProcessCallback directly

[zturner]

It's too bad llvm doesn't have an equivalent of boost::any, because that
would be perfect here :-/

[emaste]

Nice.

For test building FreeBSD, snapshot VM images are available at ftp://ftp.freebsd.org/pub/FreeBSD/snapshots/VM-IMAGES/11.0-CURRENT/amd64/Latest/ and I have some instructions for building lldb on FreeBSD at https://wiki.freebsd.org/lldb.

[labath]

Remove the typedef and add changes to windows, osx, and freebsd-specific code. I didn't
try building NetBSD, but given that there is no Plugins/Process/NetBSD, I don't think I
need to do any changes there at all. I'll keep an eye out on the buildbots after
submitting this.

I'd like to draw attention to the osx change in Host.mm in particular, as I not too
familiar with objjective c, but making a copy there made the thing work for me (without
that, I was getting errors, presumably because the block was only capturing the
reference, which was not enough if to keep the function object alive).

[labath]

In D20106#426224, @zturner wrote:

It's too bad llvm doesn't have an equivalent of boost::any, because that
would be perfect here :-/

I actually think that a std::function is better here than an any type because it ensures type safety (even though std::function will use something equivalent to any underneath). What makes this API slightly cumbersome in my mind is the fact that we have 4 arguments which we are forwarding. If we condensed that into say 2 (pid, and a struct StopInfo), then I think it would be perfect.

[krytarowski]

I'm going to test NetBSD.

lldb/trunk/include/lldb/Host/Host.h

 /// @brief A class that provides host computer information.
 ///
 /// Host is a class that answers information about the host operating
 /// system.
 //----------------------------------------------------------------------
 class Host
 {
 public:
-
-    typedef bool (*MonitorChildProcessCallback) (void *callback_baton,
-                                                 lldb::pid_t pid,
-                                                 bool exited,
-                                                 int signal,    // Zero for no signal
-                                                 int status);   // Exit value of process if signal is zero
+    typedef std::function<bool(lldb::pid_t pid, bool exited,
+                               int signal,  // Zero for no signal
+                               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.
     ///
     /// @param[in] callback
     ///     A function callback to call when a child receives a signal
     ///     (if \a monitor_signals is true) or a child exits.
     ///
-    /// @param[in] callback_baton
-    ///     A void * of user data that will be pass back when
-    ///     \a callback is called.
-    ///
     /// @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.
     ///
     /// @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 HostThread StartMonitoringChildProcess(MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid,
-                                                  bool monitor_signals);
+    static HostThread
+    StartMonitoringChildProcess(const MonitorChildProcessCallback &callback, lldb::pid_t pid, bool monitor_signals);
 
     enum SystemLogType
     {
         eSystemLogWarning,
         eSystemLogError
     };
 
     static void

lldb/trunk/include/lldb/Host/HostNativeProcessBase.h

public:
     virtual bool IsRunning() const = 0;
 
     lldb::process_t
     GetSystemHandle() const
     {
         return m_process;
     }
 
-    virtual HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals) = 0;
+    virtual HostThread
+    StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals) = 0;
 
-  protected:
     lldb::process_t m_process;
 };
 
 }
 
 #endif

lldb/trunk/include/lldb/Host/HostProcess.h

 //===-- HostProcess.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_HostProcess_h_
 #define lldb_Host_HostProcess_h_
 
+#include "lldb/Host/Host.h"
 #include "lldb/lldb-types.h"
 
 //----------------------------------------------------------------------
 /// @class HostInfo HostInfo.h "lldb/Host/HostProcess.h"
 /// @brief A class that represents a running process on the host machine.
 ///
 /// HostProcess allows querying and manipulation of processes running on the
 /// host machine.  It is not intended to be represent a process which is

 namespace lldb_private
 {
 
 class HostNativeProcessBase;
 class HostThread;
 
 class HostProcess
 {
-  public:
-    typedef bool (*MonitorCallback)(void *callback_baton, lldb::pid_t process, bool exited, int signal, int status);
-
     HostProcess();
     HostProcess(lldb::process_t process);
     ~HostProcess();
 
     Error Terminate();
     Error GetMainModule(FileSpec &file_spec) const;
 
     lldb::pid_t GetProcessId() const;
     bool IsRunning() const;
 
-    HostThread StartMonitoring(MonitorCallback callback, void *callback_baton, bool monitor_signals);
+    HostThread
+    StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals);
 
     HostNativeProcessBase &GetNativeProcess();
     const HostNativeProcessBase &GetNativeProcess() const;
 
   private:
     std::shared_ptr<HostNativeProcessBase> m_native_process;
 };
 
 }
 
 #endif

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

public:
     static Error Signal(lldb::process_t process, int signo);
 
     Error Terminate() override;
     Error GetMainModule(FileSpec &file_spec) const override;
 
     lldb::pid_t GetProcessId() const override;
     bool IsRunning() const override;
 
-    HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals) override;
+    HostThread
+    StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals) override;
 };
 
 } // namespace lldb_private
 
 #endif // lldb_Host_HostProcesPosix_h_

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

public:
     void SetOwnsHandle(bool owns);
 
     virtual Error Terminate();
     virtual Error GetMainModule(FileSpec &file_spec) const;
 
     virtual lldb::pid_t GetProcessId() const;
     virtual bool IsRunning() const;
 
-    virtual HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals);
+    HostThread
+    StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals) override;
 
-  private:
     static lldb::thread_result_t MonitorThread(void *thread_arg);
 
     void Close();
 
     bool m_owns_handle;
 };
 }
 
 #endif

lldb/trunk/include/lldb/Target/Process.h

#endif // SWIG
     /// Host::StartMonitoringChildProcess ().
     ///
     /// This function can be used by lldb_private::Process subclasses
     /// when they want to watch for a local process and have its exit
     /// status automatically set when the host child process exits.
     /// Subclasses should call Host::StartMonitoringChildProcess ()
     /// with:
     ///     callback = Process::SetHostProcessExitStatus
-    ///     callback_baton = nullptr
     ///     pid = Process::GetID()
     ///     monitor_signals = false
     //------------------------------------------------------------------
     static bool
-    SetProcessExitStatus(void *callback_baton,   // The callback baton which should be set to nullptr
-                         lldb::pid_t pid,        // The process ID we want to monitor
+    SetProcessExitStatus(lldb::pid_t pid, // The process ID we want to monitor
                          bool exited,
-                         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
 
     lldb::ByteOrder
     GetByteOrder () const;
     
     uint32_t
     GetAddressByteSize () const;
 
     uint32_t

lldb/trunk/include/lldb/Target/ProcessLaunchInfo.h

public:
         bool
         ConvertArgumentsForLaunchingInShell (Error &error,
                                              bool localhost,
                                              bool will_debug,
                                              bool first_arg_is_full_shell_command,
                                              int32_t num_resumes);
 
         void
-        SetMonitorProcessCallback (Host::MonitorChildProcessCallback callback,
-                                   void *baton,
-                                   bool monitor_signals);
+        SetMonitorProcessCallback(const Host::MonitorChildProcessCallback &callback, bool monitor_signals);
 
         Host::MonitorChildProcessCallback
         GetMonitorProcessCallback() const
         {
             return m_monitor_callback;
         }
 
-        void *
-        GetMonitorProcessBaton() const
-        {
-            return m_monitor_callback_baton;
-        }
-
         bool
         GetMonitorSignals() const
         {
             return m_monitor_signals;
         }
 
         // 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

lldb/trunk/source/Host/common/Host.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 #if !defined (__APPLE__) && !defined (_WIN32)
 struct MonitorInfo
 {
     lldb::pid_t pid;                            // The process ID to monitor
     Host::MonitorChildProcessCallback callback; // The callback function to call when "pid" exits or signals
-    void *callback_baton;                       // The callback baton for the callback function
     bool monitor_signals;                       // If true, call the callback when "pid" gets signaled.
 };
 
 static thread_result_t
 MonitorChildProcessThreadFunction (void *arg);
 
 HostThread
-Host::StartMonitoringChildProcess(Host::MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid, bool monitor_signals)
+Host::StartMonitoringChildProcess(const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
+                                  bool monitor_signals)
 {
     MonitorInfo * info_ptr = new MonitorInfo();
 
     info_ptr->pid = pid;
     info_ptr->callback = callback;
-    info_ptr->callback_baton = callback_baton;
     info_ptr->monitor_signals = monitor_signals;
     
     char thread_name[256];
     ::snprintf(thread_name, sizeof(thread_name), "<lldb.host.wait4(pid=%" PRIu64 ")>", pid);
     return ThreadLauncher::LaunchThread(thread_name, MonitorChildProcessThreadFunction, info_ptr, NULL);
 }
 
 #ifndef __linux__
MonitorChildProcessThreadFunction (void *arg)
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const char *function = __FUNCTION__;
     if (log)
         log->Printf ("%s (arg = %p) thread starting...", function, arg);
 
     MonitorInfo *info = (MonitorInfo *)arg;
 
     const Host::MonitorChildProcessCallback callback = info->callback;
-    void * const callback_baton = info->callback_baton;
     const bool monitor_signals = info->monitor_signals;
 
     assert (info->pid <= UINT32_MAX);
     const ::pid_t pid = monitor_signals ? -1 * getpgid(info->pid) : info->pid;
 
     delete info;
 
     int status = -1;
#endif
                                  status_cstr,
                                  signal,
                                  exit_status);
 
                 if (exited || (signal != 0 && monitor_signals))
                 {
                     bool callback_return = false;
                     if (callback)
-                        callback_return = callback (callback_baton, wait_pid, exited, signal, exit_status);
-                    
+                        callback_return = callback(wait_pid, exited, signal, exit_status);
                     // If our process exited, then this thread should exit
                     if (exited && wait_pid == abs(pid))
                     {
                         if (log)
                             log->Printf ("%s (arg = %p) thread exiting because pid received exit signal...", __FUNCTION__, arg);
                         break;
                     }
                     // If the callback returns true, it means this process should
Host::FindProcessThreads (const lldb::pid_t pid, TidMap &tids_to_attach)
     return false;
 }
 #endif
 
 struct ShellInfo
 {
     ShellInfo () :
         process_reaped (false),
-        can_delete (false),
         pid (LLDB_INVALID_PROCESS_ID),
         signo(-1),
         status(-1)
     {
     }
 
     lldb_private::Predicate<bool> process_reaped;
-    lldb_private::Predicate<bool> can_delete;
     lldb::pid_t pid;
     int signo;
     int status;
 };
 
 static bool
-MonitorShellCommand (void *callback_baton,
-                     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
+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
 {
-    ShellInfo *shell_info = (ShellInfo *)callback_baton;
     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(1, eBroadcastAlways);
-    // Now wait for a handshake back from that thread running Host::RunShellCommand
-    // so we know that we can delete shell_info_ptr
-    shell_info->can_delete.WaitForValueEqualTo(true);
-    // Sleep a bit to allow the shell_info->can_delete.SetValue() to complete...
-    usleep(1000);
-    // Now delete the shell info that was passed into this function
-    delete shell_info;
+    shell_info->process_reaped.SetValue(true, eBroadcastAlways);
     return true;
 }
 
 Error
 Host::RunShellCommand(const char *command,
                       const FileSpec &working_dir,
                       int *status_ptr,
                       int *signo_ptr,
if (output_file_spec)
         launch_info.AppendOpenFileAction(STDOUT_FILENO, output_file_spec, false, true);
         launch_info.AppendDuplicateFileAction(STDOUT_FILENO, STDERR_FILENO);
     }
     else
     {
         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);
         launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true);
     }
-    
-    // The process monitor callback will delete the 'shell_info_ptr' below...
-    std::unique_ptr<ShellInfo> shell_info_ap (new ShellInfo());
-    
+    std::shared_ptr<ShellInfo> shell_info_sp(new ShellInfo());
     const bool monitor_signals = false;
-    launch_info.SetMonitorProcessCallback(MonitorShellCommand, shell_info_ap.get(), monitor_signals);
-    
+    launch_info.SetMonitorProcessCallback(std::bind(MonitorShellCommand, shell_info_sp, std::placeholders::_1,
+                                                    std::placeholders::_2, std::placeholders::_3,
+                                                    std::placeholders::_4),
+                                          monitor_signals);
     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())
     {
-        // The process successfully launched, so we can defer ownership of
-        // "shell_info" to the MonitorShellCommand callback function that will
-        // get called when the process dies. We release the unique pointer as it
-        // doesn't need to delete the ShellInfo anymore.
-        ShellInfo *shell_info = shell_info_ap.release();
         TimeValue *timeout_ptr = nullptr;
         TimeValue timeout_time(TimeValue::Now());
         if (timeout_sec > 0) {
             timeout_time.OffsetWithSeconds(timeout_sec);
             timeout_ptr = &timeout_time;
         }
         bool timed_out = false;
-        shell_info->process_reaped.WaitForValueEqualTo(true, timeout_ptr, &timed_out);
+        shell_info_sp->process_reaped.WaitForValueEqualTo(true, timeout_ptr, &timed_out);
         if (timed_out)
         {
             error.SetErrorString("timed out waiting for shell command to complete");
             
             // Kill the process since it didn't complete within the timeout specified
             Kill (pid, SIGKILL);
             // Wait for the monitor callback to get the message
             timeout_time = TimeValue::Now();
             timeout_time.OffsetWithSeconds(1);
             timed_out = false;
-            shell_info->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out);
+            shell_info_sp->process_reaped.WaitForValueEqualTo(true, &timeout_time, &timed_out);
         }
         else
         {
             if (status_ptr)
-                *status_ptr = shell_info->status;
-            
+                *status_ptr = shell_info_sp->status;
             if (signo_ptr)
-                *signo_ptr = shell_info->signo;
-            
+                *signo_ptr = shell_info_sp->signo;
             if (command_output_ptr)
             {
                 command_output_ptr->clear();
                 uint64_t file_size = output_file_spec.GetByteSize();
                 if (file_size > 0)
                 {
                     if (file_size > command_output_ptr->max_size())
                     {
                         error.SetErrorStringWithFormat("shell command output is too large to fit into a std::string");
                     }
                     else
                     {
                         std::vector<char> command_output(file_size);
                         output_file_spec.ReadFileContents(0, command_output.data(), file_size, &error);
                         if (error.Success())
                             command_output_ptr->assign(command_output.data(), file_size);
                     }
                 }
             }
         }
-        shell_info->can_delete.SetValue(true, eBroadcastAlways);
     }
 
     if (FileSystem::GetFileExists(output_file_spec))
         FileSystem::Unlink(output_file_spec);
-    // Handshake with the monitor thread, or just let it know in advance that
-    // it can delete "shell_info" in case we timed out and were not able to kill
-    // the process...
     return error;
 }
 
 // LaunchProcessPosixSpawn for Apple, Linux, FreeBSD and other GLIBC
 // systems
 
 #if defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__)
 #if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)

lldb/trunk/source/Host/common/HostProcess.cpp

 }
 
 bool HostProcess::IsRunning() const
 {
     return m_native_process->IsRunning();
 }
 
 HostThread
-HostProcess::StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals)
+HostProcess::StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals)
 {
-    return m_native_process->StartMonitoring(callback, callback_baton, monitor_signals);
+    return m_native_process->StartMonitoring(callback, monitor_signals);
 }
 
 HostNativeProcessBase &HostProcess::GetNativeProcess()
 {
     return *m_native_process;
 }
 
 const HostNativeProcessBase &HostProcess::GetNativeProcess() const
 {
     return *m_native_process;
 }

lldb/trunk/source/Host/common/MonitoringProcessLauncher.cpp

MonitoringProcessLauncher::LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error)
     HostProcess process = m_delegate_launcher->LaunchProcess(resolved_info, error);
 
     if (process.GetProcessId() != LLDB_INVALID_PROCESS_ID)
     {
         Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
         Host::MonitorChildProcessCallback callback = launch_info.GetMonitorProcessCallback();
 
-        void *baton = nullptr;
         bool monitor_signals = false;
         if (callback)
         {
             // If the ProcessLaunchInfo specified a callback, use that.
-            baton = launch_info.GetMonitorProcessBaton();
             monitor_signals = launch_info.GetMonitorSignals();
         }
         else
         {
             callback = Process::SetProcessExitStatus;
         }
 
-        process.StartMonitoring(callback, baton, monitor_signals);
+        process.StartMonitoring(callback, monitor_signals);
         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/trunk/source/Host/macosx/Host.mm

if (pid != LLDB_INVALID_PROCESS_ID)
         {
             const bool monitor_signals = false;
             Host::MonitorChildProcessCallback callback = nullptr;
             
             if (!launch_info.GetFlags().Test(lldb::eLaunchFlagDontSetExitStatus))
                 callback = Process::SetProcessExitStatus;
 
             StartMonitoringChildProcess (callback,
-                                         NULL, 
                                          pid, 
                                          monitor_signals);
         }
     }
     else
     {
         // Invalid process ID, something didn't go well
         if (error.Success())
if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments))
             launch_info.GetArguments().AppendArgument(str_sp->GetValue().c_str());
         }
     }
     
     return error;
 }
 
 HostThread
-Host::StartMonitoringChildProcess(Host::MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid, bool monitor_signals)
+Host::StartMonitoringChildProcess(const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
+                                  bool monitor_signals)
 {
     unsigned long mask = DISPATCH_PROC_EXIT;
     if (monitor_signals)
         mask |= DISPATCH_PROC_SIGNAL;
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS));
 
 
     dispatch_source_t source = ::dispatch_source_create (DISPATCH_SOURCE_TYPE_PROC,
                                                          pid,
                                                          mask,
                                                          ::dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT,0));
 
     if (log)
         log->Printf("Host::StartMonitoringChildProcess "
-                    "(callback=%p, baton=%p, pid=%i, monitor_signals=%i) "
+                    "(callback, pid=%i, monitor_signals=%i) "
                     "source = %p\n",
-                    reinterpret_cast<void *>(callback), callback_baton,
-                    static_cast<int>(pid), monitor_signals,
-                    reinterpret_cast<void *>(source));
+                    static_cast<int>(pid), monitor_signals, reinterpret_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;
if (source)
                     log->Printf ("::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)
-                    cancel = callback (callback_baton, pid, exited, signal, exit_status);
+                if (callback_copy)
+                    cancel = callback_copy(pid, exited, signal, exit_status);
 
                 if (exited || cancel)
                 {
                     ::dispatch_source_cancel(source);
                 }
             }
         });
 

lldb/trunk/source/Host/posix/HostProcessPosix.cpp

if (m_process == kInvalidPosixProcess)
         return false;
 
     // Send this process the null signal.  If it succeeds the process is running.
     Error error = Signal(0);
     return error.Success();
 }
 
 HostThread
-HostProcessPosix::StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals)
+HostProcessPosix::StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals)
 {
-    return Host::StartMonitoringChildProcess(callback, callback_baton, m_process, monitor_signals);
+    return Host::StartMonitoringChildProcess(callback, m_process, monitor_signals);
 }

lldb/trunk/source/Host/windows/Host.cpp

Host::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
     process_info.SetProcessID(pid);
     GetProcessExecutableAndTriple(handle, process_info);
 
     // Need to read the PEB to get parent process and command line arguments.
     return true;
 }
 
 HostThread
-Host::StartMonitoringChildProcess(Host::MonitorChildProcessCallback callback, void *callback_baton, lldb::pid_t pid, bool monitor_signals)
+Host::StartMonitoringChildProcess(const Host::MonitorChildProcessCallback &callback, lldb::pid_t pid,
+                                  bool monitor_signals)
 {
     return HostThread();
 }
 
 Error
 Host::ShellExpandArguments (ProcessLaunchInfo &launch_info)
 {
     Error error;

lldb/trunk/source/Host/windows/HostProcessWindows.cpp

 #include <Psapi.h>
 
 using namespace lldb_private;
 
 namespace
 {
 struct MonitorInfo
 {
-    HostProcess::MonitorCallback callback;
-    void *baton;
+    Host::MonitorChildProcessCallback callback;
     HANDLE process_handle;
 };
 }
 
 HostProcessWindows::HostProcessWindows()
     : HostNativeProcessBase()
     , m_owns_handle(true)
 {
bool HostProcessWindows::IsRunning() const
     DWORD code = 0;
     if (!::GetExitCodeProcess(m_process, &code))
         return false;
 
     return (code == STILL_ACTIVE);
 }
 
 HostThread
-HostProcessWindows::StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals)
+HostProcessWindows::StartMonitoring(const Host::MonitorChildProcessCallback &callback, bool monitor_signals)
 {
     HostThread monitor_thread;
     MonitorInfo *info = new MonitorInfo;
     info->callback = callback;
-    info->baton = callback_baton;
 
     // 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.
     HostThread result;
     if (::DuplicateHandle(GetCurrentProcess(), m_process, GetCurrentProcess(), &info->process_handle, 0, FALSE, DUPLICATE_SAME_ACCESS))
         result = ThreadLauncher::LaunchThread("ChildProcessMonitor", HostProcessWindows::MonitorThread, info, nullptr);
     return result;
 }
 
 lldb::thread_result_t
 HostProcessWindows::MonitorThread(void *thread_arg)
 {
     DWORD exit_code;
 
     MonitorInfo *info = static_cast<MonitorInfo *>(thread_arg);
     if (info)
     {
         ::WaitForSingleObject(info->process_handle, INFINITE);
         ::GetExitCodeProcess(info->process_handle, &exit_code);
-        info->callback(info->baton, ::GetProcessId(info->process_handle), true, 0, exit_code);
+        info->callback(::GetProcessId(info->process_handle), true, 0, exit_code);
         ::CloseHandle(info->process_handle);
         delete (info);
     }
     return 0;
 }
 
 void HostProcessWindows::Close()
 {
     if (m_owns_handle && m_process != LLDB_INVALID_PROCESS)
         ::CloseHandle(m_process);
     m_process = nullptr;
 }

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessMonitor.h

private:
 
     static void
     ServeOperation(OperationArgs *args);
 
     static bool
     DupDescriptor(const lldb_private::FileSpec &file_spec, int fd, int flags);
 
     static bool
-    MonitorCallback(void *callback_baton,
-                    lldb::pid_t pid, bool exited, int signal, int status);
+    MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid, bool exited, int signal, int status);
 
     static ProcessMessage
     MonitorSIGTRAP(ProcessMonitor *monitor,
                    const siginfo_t *info, lldb::pid_t pid);
 
     static ProcessMessage
     MonitorSignal(ProcessMonitor *monitor, 
                   const siginfo_t *info, lldb::pid_t pid);

lldb/trunk/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process,
                                const FileSpec &working_dir,
                                const lldb_private::ProcessLaunchInfo & /* launch_info */,
                                lldb_private::Error &error)
     : m_process(static_cast<ProcessFreeBSD *>(process)),
       m_pid(LLDB_INVALID_PROCESS_ID),
       m_terminal_fd(-1),
       m_operation(0)
 {
+    using namespace std::placeholders;
+
     std::unique_ptr<LaunchArgs> args(new LaunchArgs(this, module, argv, envp,
                                                     stdin_file_spec,
                                                     stdout_file_spec,
                                                     stderr_file_spec,
                                                     working_dir));
     
 
     sem_init(&m_operation_pending, 0, 0);
WAIT_AGAIN:
     {
         StopOpThread();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess(
-        ProcessMonitor::MonitorCallback, this, GetPID(), true);
+        std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4), GetPID(), true);
     if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Process launch failed.");
         return;
     }
 }
 
 ProcessMonitor::ProcessMonitor(ProcessFreeBSD *process,
                                lldb::pid_t pid,
                                lldb_private::Error &error)
     : m_process(static_cast<ProcessFreeBSD *>(process)),
       m_pid(pid),
       m_terminal_fd(-1),
       m_operation(0)
 {
+    using namespace std::placeholders;
+
     sem_init(&m_operation_pending, 0, 0);
     sem_init(&m_operation_done, 0, 0);
 
 
     std::unique_ptr<AttachArgs> args(new AttachArgs(this, pid));
 
     StartAttachOpThread(args.get(), error);
     if (!error.Success())
WAIT_AGAIN:
     {
         StopOpThread();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess(
-        ProcessMonitor::MonitorCallback, this, GetPID(), true);
+        std::bind(&ProcessMonitor::MonitorCallback, this, _1, _2, _3, _4), GetPID(), true);
     if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Process attach failed.");
         return;
     }
 }
 
if (PTRACE(PT_GETLWPLIST, m_pid, (void *)tids, tdcnt) < 0) {
         return 0;
     }
     thread_ids = std::vector<lldb::tid_t>(tids, tids + tdcnt);
     free(tids);
     return thread_ids.size();
 }
 
 bool
-ProcessMonitor::MonitorCallback(void *callback_baton,
-                                lldb::pid_t pid,
-                                bool exited,
-                                int signal,
-                                int status)
+ProcessMonitor::MonitorCallback(ProcessMonitor *monitor, lldb::pid_t pid, bool exited, int signal, int status)
 {
     ProcessMessage message;
-    ProcessMonitor *monitor = static_cast<ProcessMonitor*>(callback_baton);
     ProcessFreeBSD *process = monitor->m_process;
     assert(process);
     bool stop_monitoring;
     struct ptrace_lwpinfo plwp;
     int ptrace_err;
 
     Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_PROCESS));
 

lldb/trunk/source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

ProcessWindowsLive::OnExitProcess(uint32_t exit_code)
     if (target)
     {
         ModuleSP executable_module = target->GetExecutableModule();
         ModuleList unloaded_modules;
         unloaded_modules.Append(executable_module);
         target->ModulesDidUnload(unloaded_modules, true);
     }
 
-    SetProcessExitStatus(nullptr, GetID(), true, 0, exit_code);
+    SetProcessExitStatus(GetID(), true, 0, exit_code);
     SetPrivateState(eStateExited);
 }
 
 void
 ProcessWindowsLive::OnDebuggerConnected(lldb::addr_t image_base)
 {
     DebuggerThreadSP debugger = m_session_data->m_debugger;
 

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

 
 private:
     bool
     KillSpawnedProcess (lldb::pid_t pid);
 
     bool
     DebugserverProcessReaped (lldb::pid_t pid);
 
-    static bool
-    ReapDebugserverProcess (void *callback_baton,
-                            lldb::pid_t pid,
-                            bool exited,
-                            int signal,
-                            int status);
-
     static const FileSpec&
     GetDomainSocketDir();
 
     static FileSpec
     GetDomainSocketPath(const char* prefix);
 
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationServerPlatform);
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif // liblldb_GDBRemoteCommunicationServerPlatform_h_

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

GDBRemoteCommunicationServerPlatform::LaunchGDBServer(const lldb_private::Args& args,
 
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
     if (log)
         log->Printf("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(ReapDebugserverProcess, this, false);
+    debugserver_launch_info.SetMonitorProcessCallback(
+        std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this, std::placeholders::_1), false);
 
     std::string platform_scheme;
     std::string platform_ip;
     int platform_port;
     std::string platform_path;
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
     UNUSED_IF_ASSERT_DISABLED(ok);
     assert(ok);
GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo(StringExtractorGDBRemote &packet)
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 bool
 GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped (lldb::pid_t pid)
 {
     Mutex::Locker locker (m_spawned_pids_mutex);
     FreePortForProcess(pid);
-    return m_spawned_pids.erase(pid) > 0;
-}
-
-bool
-GDBRemoteCommunicationServerPlatform::ReapDebugserverProcess (void *callback_baton,
-                                                   lldb::pid_t pid,
-                                                   bool exited,
-                                                   int signal,    // Zero for no signal
-                                                   int status)    // Exit value of process if signal is zero
-{
-    GDBRemoteCommunicationServerPlatform *server = (GDBRemoteCommunicationServerPlatform *)callback_baton;
-    server->DebugserverProcessReaped (pid);
+    m_spawned_pids.erase(pid);
     return true;
 }
 
 Error
 GDBRemoteCommunicationServerPlatform::LaunchProcess ()
 {
     if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
         return Error ("%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(ReapDebugserverProcess, this, false);
+        m_process_launch_info.SetMonitorProcessCallback(
+            std::bind(&GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped, this, std::placeholders::_1),
+            false);
 
     Error error = m_platform_sp->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/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
 
     void
     StopAsyncThread ();
 
     static lldb::thread_result_t
     AsyncThread (void *arg);
 
     static bool
-    MonitorDebugserverProcess (void *callback_baton,
-                               lldb::pid_t pid,
-                               bool exited,
-                               int signo,
-                               int exit_status);
+    MonitorDebugserverProcess(ProcessGDBRemote *process, lldb::pid_t pid, bool exited, int signo, int exit_status);
 
     lldb::StateType
     SetThreadStopInfo (StringExtractor& stop_packet);
 
     bool
     GetThreadStopInfoFromJSON (ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp);
 
     lldb::ThreadSP

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

if (error.Fail())
             error_string = "unable to launch " DEBUGSERVER_BASENAME;
     }
     return error;
 }
 
 Error
 ProcessGDBRemote::LaunchAndConnectToDebugserver (const ProcessInfo &process_info)
 {
+    using namespace std::placeholders; // For _1, _2, etc.
+
     Error error;
     if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID)
     {
         // If we locate debugserver, keep that located version around
         static FileSpec g_debugserver_file_spec;
 
         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);
 
-        debugserver_launch_info.SetMonitorProcessCallback (MonitorDebugserverProcess, this, false);
+        debugserver_launch_info.SetMonitorProcessCallback(std::bind(MonitorDebugserverProcess, this, _1, _2, _3, _4),
+                                                          false);
         debugserver_launch_info.SetUserID(process_info.GetUserID());
 
 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
         // On iOS, still do a local connection using a random port
         const char *hostname = "127.0.0.1";
         uint16_t port = get_random_port ();
 #else
         // Set hostname being NULL to do the reverse connect where debugserver
#endif
             error = ConnectToDebugserver (connect_url.GetString().c_str());
         }
 
     }
     return error;
 }
 
 bool
-ProcessGDBRemote::MonitorDebugserverProcess
-(
-    void *callback_baton,
-    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
+ProcessGDBRemote::MonitorDebugserverProcess(ProcessGDBRemote *process, 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
                                             )
 {
     // The baton is a "ProcessGDBRemote *". Now this class might be gone
     // and might not exist anymore, so we need to carefully try to get the
     // target for this process first since we have a race condition when
     // we are done running between getting the notice that the inferior
     // process has died and the debugserver that was debugging this process.
     // In our test suite, we are also continually running process after
     // process, so we must be very careful to make sure:
     // 1 - process object hasn't been deleted already
     // 2 - that a new process object hasn't been recreated in its place
 
     // "debugserver_pid" argument passed in is the process ID for
     // debugserver that we are tracking...
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 
-    ProcessGDBRemote *process = (ProcessGDBRemote *)callback_baton;
-
     // Get a shared pointer to the target that has a matching process pointer.
     // This target could be gone, or the target could already have a new process
     // object inside of it
     TargetSP target_sp (Debugger::FindTargetWithProcess(process));
 
     if (log)
-        log->Printf ("ProcessGDBRemote::MonitorDebugserverProcess (baton=%p, pid=%" PRIu64 ", signo=%i (0x%x), exit_status=%i)", callback_baton, debugserver_pid, signo, signo, exit_status);
+        log->Printf("ProcessGDBRemote::%s(process=%p, pid=%" PRIu64 ", signo=%i (0x%x), exit_status=%i)", __FUNCTION__,
+                    process, debugserver_pid, signo, signo, exit_status);
 
     if (target_sp)
     {
         // We found a process in a target that matches, but another thread
         // might be in the process of launching a new process that will
         // soon replace it, so get a shared pointer to the process so we
         // can keep it alive.
         ProcessSP process_sp (target_sp->GetProcessSP());

lldb/trunk/source/Target/Process.cpp

Process::IsAlive ()
     }
 }
 
 // This static callback can be used to watch for local child processes on
 // the current host. The child process exits, the process will be
 // found in the global target list (we want to be completely sure that the
 // lldb_private::Process doesn't go away before we can deliver the signal.
 bool
-Process::SetProcessExitStatus (void *callback_baton,
-                               lldb::pid_t pid,
-                               bool exited,
-                               int signo,          // Zero for no signal
-                               int exit_status     // Exit value of process if signal is zero
+Process::SetProcessExitStatus(lldb::pid_t pid, bool exited,
+                              int signo,      // Zero for no signal
+                              int exit_status // Exit value of process if signal is zero
                               )
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
-        log->Printf ("Process::SetProcessExitStatus (baton=%p, pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n",
-                     callback_baton,
-                     pid,
-                     exited,
-                     signo,
-                     exit_status);
+        log->Printf("Process::SetProcessExitStatus (pid=%" PRIu64 ", exited=%i, signal=%i, exit_status=%i)\n", pid,
+                    exited, signo, exit_status);
 
     if (exited)
     {
         TargetSP target_sp(Debugger::FindTargetWithProcessID (pid));
         if (target_sp)
         {
             ProcessSP process_sp (target_sp->GetProcessSP());
             if (process_sp)

lldb/trunk/source/Target/ProcessLaunchInfo.cpp

ProcessLaunchInfo::Clear ()
     m_flags.Clear();
     m_file_actions.clear();
     m_resume_count = 0;
     m_listener_sp.reset();
     m_hijack_listener_sp.reset();
 }
 
 void
-ProcessLaunchInfo::SetMonitorProcessCallback (Host::MonitorChildProcessCallback callback,
-                           void *baton,
-                           bool monitor_signals)
+ProcessLaunchInfo::SetMonitorProcessCallback(const Host::MonitorChildProcessCallback &callback, bool monitor_signals)
 {
     m_monitor_callback = callback;
-    m_monitor_callback_baton = baton;
     m_monitor_signals = monitor_signals;
 }
 
 bool
 ProcessLaunchInfo::MonitorProcess () const
 {
     if (m_monitor_callback && ProcessIDIsValid())
     {
         Host::StartMonitoringChildProcess (m_monitor_callback,
-                                           m_monitor_callback_baton,
                                            GetProcessID(),
                                            m_monitor_signals);
         return true;
     }
     return false;
 }
 
 void