Use non-blocking waitpid in NativeProcessLinux

[labath]

Summary

This is the first phase of the merging of Monitor and Operation threads in NativeProcessLinux
(which is necessary since the two threads race inside Linux kernel). Here, I reimplement the
Monitor thread do use non-blocking waitpid calls, which enables later addition of code from the
operation thread.

[labath]

Close monitor fd in case monitor initialization fails.

[ovyalov]

Please see my comments.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1158

There is no likelihood of partial read here, right?

1173

Could you split this method into 2 smaller methods - for example, ReadSignal and ProcessSignal?

1248

Should we return from this call if size == 0?

1250

Could you use 'x' to check for exit command?

1275

s/NativeProcessLinux::/NativeProcessLinux::Monitor

1283

What do you think about handling commands prior to signals? Otherwise, if there is constant stream of signals exit may take time.

4007

s/NULL/nullptr

4011

"Process attach" - is it still relevant in this context?

4021

You may return here if !IsJoinable().

[tberghammer]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1248–1254

Why do we need this switch here?

1270

(nit: ::select())

3998

Please use a unique_ptr and do a release when we pass ownership to the other thread. I would suggest to use the same semantics for closing monitro_fd also.

source/Plugins/Process/Linux/NativeProcessLinux.h

200

Do we need to define this class in the header file?

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1158

Reading from the fd actually handles the signal, so it would be very strange to "partially" handle it. I have added this logging statement just in case...

1173

Done.

1248

I have changed this to use end-of-file signal (size==0) as the exit signal.

1248–1254

That was me preparing for more commands in later patches. In any case, it is gone now...

1250

I will use end-of-file as exit command. This means there are no supported commands (yet). Changed to log if we receive an unknown command.

1270

What is the policy on prefixing stuff with :: ?
I am using a ton of system calls from the global namespace here... Should I prefix all of them??

1275

Good catch.

1283

Sounds unlikely, but I can do that just in case.

3998

That's not as easy as it looks like. Let's say I put the monitor in a unique_ptr and I call LaunchThread(..., monitor_up.release(), ...).
What happens if the thread creation fails? LaunchThread will not delete raw pointer, and since I have just nuked my last pointer to the monitor by calling release, I cannot delete it myself either.
There is a couple of ways to avoid that I can think of, but all involve holding a raw pointer of the object at some point and are more complicated that doing it with a raw pointer from the start. I would be interested in seeing a counter-example though. :)

I was actually looking for a file descriptor RAII class, but I could not find any. LLVM has ScopedHandle for windows file handles, but there is no linux/posix equivalent. The best solution would be to add one to llvm, but I did not want to go that way at the moment. :(

4007

Done.

4011

Good point, rephrasing.

4021

Refactored.

source/Plugins/Process/Linux/NativeProcessLinux.h

200

It needs access to private methods of NativeProcessLinux (MonitorCallback, at least).

[labath]

• respond to review comments
• make pipe fds synchronous (I never relied on them async in the first place)

[tberghammer]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1270

I don't know (I usually use them with :: to avoid any name conflict in the future but I think we don't have any policy).

3998

I would use a unique_ptr like this (it is cleaner for me but you can leave it as it is now if you like it more):

std::unique_ptr<Monitor> monitor(new Monitor(...))
...
 m_monitor_thread = ThreadLauncher::LaunchThread("monitor", Monitor::RunMonitor, monitor.get(), NULL);
if (m_monitor_thread.IsJoinable())
    monitor.release();
else
{
    ...
}

For the file handle I would suggest to create a RAII based on std::unique_ptr with a lambda here and use it next to the monitor unique_ptr.
Something like this (not tested):

auto fd_deleter = [](int* fd){close(*fd); *fd = -1;}
std::unique_ptr<int, decltype(fd_deleter)> monitor_fd_scope(&m_monitor_fd);

[labath]

source/Plugins/Process/Linux/NativeProcessLinux.cpp

3998

I have redesigned this a bit. Now the Monitor is owned (via a unique_ptr) by the NativeProcessLinux object, and all the destruction (threads, file descriptors...) happens in the Monitor destructor, which sounds more RAII. What do you make of this?

[labath]

redesign the monitor class to make it more RAII

[tberghammer]

Looks good, thanks for rewriting it in RAII

[ovyalov]

LGTM

source/Plugins/Process/Linux/NativeProcessLinux.h

protected:
         Error
         GetSoftwareBreakpointTrapOpcode (size_t trap_opcode_size_hint, size_t &actual_opcode_size, const uint8_t *&trap_opcode_bytes) override;
 
     private:
 
         ArchSpec m_arch;
 
         HostThread m_operation_thread;
+        int m_monitor_fd = -1;
         HostThread m_monitor_thread;
 
         // current operation which must be executed on the priviliged thread
         void *m_operation;
         Mutex m_operation_mutex;
 
         // semaphores notified when Operation is ready to be processed and when
         // the operation is complete.
         sem_t m_operation_pending;
         sem_t m_operation_done;
 
         LazyBool m_supports_mem_region;
         std::vector<MemoryRegionInfo> m_mem_region_cache;
         Mutex m_mem_region_cache_mutex;
 
         std::unique_ptr<ThreadStateCoordinator> m_coordinator_up;
         HostThread m_coordinator_thread;
 
         // List of thread ids stepping with a breakpoint with the address of
         // the relevan breakpoint
         std::map<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
 
+        class Monitor;
+
         struct OperationArgs
         {
             OperationArgs(NativeProcessLinux *monitor);
 
             ~OperationArgs();
 
             NativeProcessLinux *m_monitor;      // The monitor performing the attach.
             sem_t m_semaphore;              // Posted to once operation complete.
private:
             Error &error);
 
         /// Attaches to an existing process.  Forms the
         /// implementation of Process::DoAttach
         void
         AttachToInferior (lldb::pid_t pid, Error &error);
 
         void
+        StartMonitorThread(Error &error);
+
+        void
         StartLaunchOpThread(LaunchArgs *args, Error &error);
 
         static void *
         LaunchOpThread(void *arg);
 
         static bool
         Launch(LaunchArgs *args);
 
private:
         SetDefaultPtraceOpts(const lldb::pid_t);
 
         static void
         ServeOperation(OperationArgs *args);
 
         static bool
         DupDescriptor(const char *path, int fd, int flags);
 
-        static bool
-        MonitorCallback(void *callback_baton,
-                lldb::pid_t pid, bool exited, int signal, int status);
+        static void *
+        MonitorThread(void *baton);
+
+        void
+        MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
 
         void
         MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
 
         void
         MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
 
         void

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include "ThreadStateCoordinator.h"
 
 // System includes - They have to be included after framework includes because they define some
 // macros which collide with variable names in other modules
 #include <linux/unistd.h>
 #include <sys/personality.h>
 #include <sys/ptrace.h>
 #include <sys/socket.h>
+#include <sys/signalfd.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <sys/user.h>
 #include <sys/wait.h>
 
 #if defined (__arm64__) || defined (__aarch64__)
 // NT_PRSTATUS and NT_FPREGSET definition
#endif
     };
 
     void
     DetachOperation::Execute(NativeProcessLinux *monitor)
     {
         PTRACE(PTRACE_DETACH, m_tid, nullptr, 0, 0, m_error);
     }
 
+} // end of anonymous namespace
+
+class NativeProcessLinux::Monitor {
+private:
+    int                 m_command_fd;
+    int                 m_signal_fd;
+    ::pid_t             m_child_pid;
+    NativeProcessLinux *m_native_process;
+
+    void
+    HandleSignals();
+
+    // Returns true if the thread should exit.
+    bool
+    HandleCommands();
+
+    void
+    MainLoop();
+
+public:
+    // Takes ownership of command_fd.
+    Monitor(int command_fd, ::pid_t child_pid, NativeProcessLinux *native_process)
+        : m_command_fd(command_fd), m_child_pid(-getpgid(child_pid)), m_native_process(native_process)
+    {}
+
+    ~Monitor();
+
+    Error
+    Initialize();
+
+    static void *
+    RunMonitor(void *arg);
+};
+
+Error
+NativeProcessLinux::Monitor::Initialize()
+{
+    // We get a SIGCHLD every time something interesting happens with the inferior. We shall be
+    // listening for these signals over a signalfd file descriptors. This allows us to wait for
+    // multiple kinds of events with select.
+    sigset_t signals;
+    sigemptyset(&signals);
+    sigaddset(&signals, SIGCHLD);
+    m_signal_fd = signalfd(-1, &signals, SFD_NONBLOCK | SFD_CLOEXEC);
+    if (m_signal_fd < 0)
+    {
+        return Error("NativeProcessLinux::Monitor::%s failed due to signalfd failure. Monitoring the inferior will be impossible: %s",
+                    __FUNCTION__, strerror(errno));
+
+    }
+    return Error();
+}
+
+NativeProcessLinux::Monitor::~Monitor()
+{
+    close(m_command_fd);
+    if (m_signal_fd >= 0)
+        close(m_signal_fd);
+}
+
+void
+NativeProcessLinux::Monitor::HandleSignals()
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // We don't really care about the content of the SIGCHLD siginfo structure, as we will get
+    // all the information from waitpid(). We just need to read all the signals so that we can
+    // sleep next time we reach select().
+    while (true)
+    {
+        signalfd_siginfo info;
+        ssize_t size = read(m_signal_fd, &info, sizeof info);
+        if (size == -1)
+        {
+            if (errno == EAGAIN || errno == EWOULDBLOCK)
+                break; // We are done.
+            if (errno == EINTR)
+                continue;
+            if (log)
+                log->Printf("NativeProcessLinux::Monitor::%s reading from signalfd file descriptor failed: %s",
+                        __FUNCTION__, strerror(errno));
+            break;
+        }
+        if (size != sizeof info)
+        {
+            // We got incomplete information structure. This should not happen, let's just log
+            // that.
+            if (log)
+                log->Printf("NativeProcessLinux::Monitor::%s reading from signalfd file descriptor returned incomplete data: "
+                        "structure size is %zd, read returned %zd bytes",
+                        __FUNCTION__, sizeof info, size);
+            break;
+        }
+        if (log)
+            log->Printf("NativeProcessLinux::Monitor::%s received signal %s(%d).", __FUNCTION__,
+                Host::GetSignalAsCString(info.ssi_signo), info.ssi_signo);
+    }
+
+    // Now get the waitpid notifications.
+    while (true)
+    {
+        int status = -1;
+        ::pid_t wait_pid = waitpid(m_child_pid, &status, __WALL | WNOHANG);
+
+        if (wait_pid == 0)
+            break; // We are done.
+
+        if (wait_pid == -1)
+        {
+            if (errno == EINTR)
+                continue;
+
+            if (log)
+              log->Printf("NativeProcessLinux::Monitor::%s waitpid (pid = %" PRIi32 ", &status, __WALL | WNOHANG) failed: %s",
+                      __FUNCTION__, m_child_pid, strerror(errno));
+            break;
         }
 
+        bool exited = false;
+        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))
+        {
+            exit_status = WEXITSTATUS(status);
+            status_cstr = "EXITED";
+            exited = true;
+        }
+        else if (WIFSIGNALED(status))
+        {
+            signal = WTERMSIG(status);
+            status_cstr = "SIGNALED";
+            if (wait_pid == m_child_pid) {
+                exited = true;
+                exit_status = -1;
+            }
+        }
+        else
+            status_cstr = "(\?\?\?)";
+
+        if (log)
+            log->Printf("NativeProcessLinux::Monitor::%s: waitpid (pid = %" PRIi32 ", &status, __WALL | WNOHANG)"
+                "=> pid = %" PRIi32 ", status = 0x%8.8x (%s), signal = %i, exit_state = %i",
+                __FUNCTION__, m_child_pid, wait_pid, status, status_cstr, signal, exit_status);
+
+        m_native_process->MonitorCallback (wait_pid, exited, signal, exit_status);
+    }
+}
+
+bool
+NativeProcessLinux::Monitor::HandleCommands()
+{
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    while (true)
+    {
+        char command = 0;
+        ssize_t size = read(m_command_fd, &command, sizeof command);
+        if (size == -1)
+        {
+            if (errno == EAGAIN || errno == EWOULDBLOCK)
+                return false;
+            if (errno == EINTR)
+                continue;
+            if (log)
+                log->Printf("NativeProcessLinux::Monitor::%s exiting because read from command file descriptor failed: %s", __FUNCTION__, strerror(errno));
+            return true;
+        }
+        switch (command)
+        {
+            default:
+                if (log)
+                    log->Printf("NativeProcessLinux::Monitor::%s exit command received, exiting...", __FUNCTION__);
+                return true; // We are done
+        }
+    }
+}
+
+void
+NativeProcessLinux::Monitor::MainLoop()
+{
+    bool exit = false;
+    while (!exit)
+    {
+        fd_set fds;
+        FD_ZERO(&fds);
+        FD_SET(m_signal_fd, &fds);
+        FD_SET(m_command_fd, &fds);
+
+        int max_fd = std::max(m_signal_fd, m_command_fd) + 1;
+        int r = select(max_fd, &fds, nullptr, nullptr, nullptr);
+        if (r < 0)
+        {
+            Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+            if (log)
+                log->Printf("NativeProcessLinux::%s exiting because select failed: %s",
+                        __FUNCTION__, strerror(errno));
+            return;
+        }
+
+        if (FD_ISSET(m_signal_fd, &fds))
+            HandleSignals();
+
+        if (FD_ISSET(m_command_fd, &fds))
+            exit = HandleCommands();
+    }
+}
+
+// Takes ownership of the Monitor object contained in arg.
+void *
+NativeProcessLinux::Monitor::RunMonitor(void *arg)
+{
+    std::unique_ptr<Monitor> monitor_up( static_cast<Monitor *>(arg));
+    monitor_up->MainLoop();
+    return nullptr;
+}
+
+
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
 static bool
 EnsureFDFlags(int fd, int flags, Error &error)
 {
     int status;
 
     if ((status = fcntl(fd, F_GETFL)) == -1)
WAIT_AGAIN:
     {
         StopOpThread();
         StopCoordinatorThread ();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
-    m_monitor_thread = Host::StartMonitoringChildProcess(
-        NativeProcessLinux::MonitorCallback, this, GetID(), true);
-    if (!m_monitor_thread.IsJoinable())
-    {
-        error.SetErrorToGenericError();
-        error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
-        return;
-    }
+    StartMonitorThread(error);
 }
 
 void
 NativeProcessLinux::AttachToInferior (lldb::pid_t pid, Error &error)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ")", __FUNCTION__, pid);
WAIT_AGAIN:
     {
         StopOpThread ();
         StopCoordinatorThread ();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
-    m_monitor_thread = Host::StartMonitoringChildProcess (
-        NativeProcessLinux::MonitorCallback, this, GetID (), true);
-    if (!m_monitor_thread.IsJoinable())
-    {
-        error.SetErrorToGenericError ();
-        error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
-        return;
-    }
+    StartMonitorThread(error);
 }
 
 void
 NativeProcessLinux::Terminate ()
 {
     StopMonitor();
 }
 
else if (WIFSTOPPED (status))
         return WSTOPSIG (status);
     else
     {
         // We don't know what this is.
         return ExitType::eExitTypeInvalid;
     }
 }
 
-// Main process monitoring waitpid-loop handler.
-bool
-NativeProcessLinux::MonitorCallback(void *callback_baton,
-                                    lldb::pid_t pid,
+// Handles all waitpid events from the inferior process.
+void
+NativeProcessLinux::MonitorCallback(lldb::pid_t pid,
                                     bool exited,
                                     int signal,
                                     int status)
 {
     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
 
-    NativeProcessLinux *const process = static_cast<NativeProcessLinux*>(callback_baton);
-    assert (process && "process is null");
-    if (!process)
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " callback_baton was null, can't determine process to use", __FUNCTION__, pid);
-        return true;
-    }
-
     // Certain activities differ based on whether the pid is the tid of the main thread.
-    const bool is_main_thread = (pid == process->GetID ());
-
-    // Assume we keep monitoring by default.
-    bool stop_monitoring = false;
+    const bool is_main_thread = (pid == GetID ());
 
     // Handle when the thread exits.
     if (exited)
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s() got exit signal(%d) , tid = %"  PRIu64 " (%s main thread)", __FUNCTION__, signal, pid, is_main_thread ? "is" : "is not");
 
         // This is a thread that exited.  Ensure we're not tracking it anymore.
-        const bool thread_found = process->StopTrackingThread (pid);
+        const bool thread_found = StopTrackingThread (pid);
 
         // Make sure the thread state coordinator knows about this.
-        process->NotifyThreadDeath (pid);
+        NotifyThreadDeath (pid);
 
         if (is_main_thread)
         {
             // We only set the exit status and notify the delegate if we haven't already set the process
             // state to an exited state.  We normally should have received a SIGTRAP | (PTRACE_EVENT_EXIT << 8)
             // for the main thread.
-            const bool already_notified = (process->GetState() == StateType::eStateExited) || (process->GetState () == StateType::eStateCrashed);
+            const bool already_notified = (GetState() == StateType::eStateExited) || (GetState () == StateType::eStateCrashed);
             if (!already_notified)
             {
                 if (log)
-                    log->Printf ("NativeProcessLinux::%s() tid = %"  PRIu64 " handling main thread exit (%s), expected exit state already set but state was %s instead, setting exit state now", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found", StateAsCString (process->GetState ()));
+                    log->Printf ("NativeProcessLinux::%s() tid = %"  PRIu64 " handling main thread exit (%s), expected exit state already set but state was %s instead, setting exit state now", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found", StateAsCString (GetState ()));
                 // The main thread exited.  We're done monitoring.  Report to delegate.
-                process->SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true);
+                SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true);
 
                 // Notify delegate that our process has exited.
-                process->SetState (StateType::eStateExited, true);
+                SetState (StateType::eStateExited, true);
             }
             else
             {
                 if (log)
                     log->Printf ("NativeProcessLinux::%s() tid = %"  PRIu64 " main thread now exited (%s)", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found");
             }
-            return true;
         }
         else
         {
             // Do we want to report to the delegate in this case?  I think not.  If this was an orderly
             // thread exit, we would already have received the SIGTRAP | (PTRACE_EVENT_EXIT << 8) signal,
             // and we would have done an all-stop then.
             if (log)
                 log->Printf ("NativeProcessLinux::%s() tid = %"  PRIu64 " handling non-main thread exit (%s)", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found");
-
-            // Not the main thread, we keep going.
-            return false;
         }
     }
 
     // Get details on the signal raised.
     siginfo_t info;
-    const auto err = process->GetSignalInfo(pid, &info);
+    const auto err = GetSignalInfo(pid, &info);
     if (err.Success())
     {
         // We have retrieved the signal info.  Dispatch appropriately.
         if (info.si_signo == SIGTRAP)
-            process->MonitorSIGTRAP(&info, pid);
+            MonitorSIGTRAP(&info, pid);
         else
-            process->MonitorSignal(&info, pid, exited);
-
-        stop_monitoring = false;
+            MonitorSignal(&info, pid, exited);
     }
     else
     {
         if (err.GetError() == EINVAL)
         {
             // This is a group stop reception for this tid.
             if (log)
-                log->Printf ("NativeThreadLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64, __FUNCTION__, process->GetID (), pid);
-            process->NotifyThreadStop (pid);
+                log->Printf ("NativeThreadLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64, __FUNCTION__, GetID (), pid);
+            NotifyThreadStop (pid);
         }
         else
         {
             // ptrace(GETSIGINFO) failed (but not due to group-stop).
 
             // A return value of ESRCH means the thread/process is no longer on the system,
             // so it was killed somehow outside of our control.  Either way, we can't do anything
             // with it anymore.
 
-            // We stop monitoring if it was the main thread.
-            stop_monitoring = is_main_thread;
-
             // Stop tracking the metadata for the thread since it's entirely off the system now.
-            const bool thread_found = process->StopTrackingThread (pid);
+            const bool thread_found = StopTrackingThread (pid);
 
             // Make sure the thread state coordinator knows about this.
-            process->NotifyThreadDeath (pid);
+            NotifyThreadDeath (pid);
 
             if (log)
                 log->Printf ("NativeProcessLinux::%s GetSignalInfo failed: %s, tid = %" PRIu64 ", signal = %d, status = %d (%s, %s, %s)",
                              __FUNCTION__, err.AsCString(), pid, signal, status, err.GetError() == ESRCH ? "thread/process killed" : "unknown reason", is_main_thread ? "is main thread" : "is not main thread", thread_found ? "thread metadata removed" : "thread metadata not found");
 
             if (is_main_thread)
             {
                 // Notify the delegate - our process is not available but appears to have been killed outside
                 // our control.  Is eStateExited the right exit state in this case?
-                process->SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true);
-                process->SetState (StateType::eStateExited, true);
+                SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true);
+                SetState (StateType::eStateExited, true);
             }
             else
             {
                 // This thread was pulled out from underneath us.  Anything to do here? Do we want to do an all stop?
                 if (log)
-                    log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " non-main thread exit occurred, didn't tell delegate anything since thread disappeared out from underneath us", __FUNCTION__, process->GetID (), pid);
+                    log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 " non-main thread exit occurred, didn't tell delegate anything since thread disappeared out from underneath us", __FUNCTION__, GetID (), pid);
             }
         }
     }
-
-    return stop_monitoring;
 }
 
 void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
NativeProcessLinux::DupDescriptor(const char *path, int fd, int flags)
 
     if (dup2(target_fd, fd) == -1)
         return false;
 
     return (close(target_fd) == -1) ? false : true;
 }
 
 void
+NativeProcessLinux::StartMonitorThread(Error &error)
+{
+    int pipefd[2];
+    if (pipe2(pipefd, O_NONBLOCK | O_CLOEXEC) == -1)
+    {
+        error.SetErrorToErrno();
+        return;
+    }
+    m_monitor_fd = pipefd[1];
+
+    Monitor *monitor = new Monitor(pipefd[0], GetID(), this);
+    error = monitor->Initialize();
+    if (error.Fail()) {
+        delete monitor;
+        close(m_monitor_fd);
+        m_monitor_fd = -1;
+        return;
+    }
+
+    m_monitor_thread = ThreadLauncher::LaunchThread("monitor", Monitor::RunMonitor, monitor, NULL);
+    if (!m_monitor_thread.IsJoinable())
+    {
+        error.SetErrorToGenericError();
+        error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
+        delete monitor;
+        close(m_monitor_fd);
+        m_monitor_fd = -1;
+    }
+}
+
+void
 NativeProcessLinux::StopMonitorThread()
 {
     if (m_monitor_thread.IsJoinable())
     {
-        ::pthread_kill(m_monitor_thread.GetNativeThread().GetSystemHandle(), SIGUSR1);
+        char x = 'x';
+        write(m_monitor_fd, &x, 1);
         m_monitor_thread.Join(nullptr);
+        close(m_monitor_fd);
+        m_monitor_fd = -1;
     }
 }
 
 void
 NativeProcessLinux::StopMonitor()
 {
     StopMonitorThread();
     StopCoordinatorThread ();

tools/lldb-server/lldb-gdbserver.cpp

 int
 main_gdbserver (int argc, char *argv[])
 {
 #ifndef _WIN32
     // Setup signal handlers first thing.
     signal (SIGPIPE, signal_handler);
     signal (SIGHUP, signal_handler);
 #endif
+#ifdef __linux__
+    // Block delivery of SIGCHLD on linux. NativeProcessLinux will read it using signalfd.
+    sigset_t set;
+    sigemptyset(&set);
+    sigaddset(&set, SIGCHLD);
+    pthread_sigmask(SIG_BLOCK, &set, NULL);
+#endif
 
     const char *progname = argv[0];
     const char *subcommand = argv[1];
     argc--;
     argv++;
     int long_option_index = 0;
     StreamSP log_stream_sp;
     Args log_args;