Introduce a MainLoop class and switch llgs to use it

[labath]

Summary

This is the first part of our effort to make llgs single threaded. Currently, llgs consists of
about three threads and the synchronisation between them is a major source of latency when
debugging linux and android applications.

In order to be able to go single threaded, we must have the ability to listen for events from
multiple sources (primarily, client commands coming over the network and debug events from the
inferior) and perform necessary actions. For this reason I introduce the concept of a MainLoop.
A main loop has the ability to register callback's which will be invoked upon receipt of certain
events. MainLoopPosix has the ability to listen for file descriptors and signals. I have also
introduced a stubbed-out implementation of MainLoopWindows, which was necessary to make code
compile on windows (this does not introduce any regression as the llgs component is not used on
windows). It is my hope that if can get a windows implementation of this class, we could
gradually replace the uses of select in lldb (which are currently #ifdefed for windows) with
MainLoop invocations.

For the moment, I have merely made the GDBRemoteCommunicationServerLLGS class use MainLoop
instead of waiting on the network socket directly, but the other threads still remain. In the
followup patches I indend to migrate NativeProcessLinux to this class and remove the remaining
threads.

[labath]

I would welcome any feedback about the general design of the class (and in particular, whether such a design is workable on windows).

[clayborg]

Since there are going to require multiple patches to make this work it might be best to do this in a branch. I worry about being able to handle everything in a single threaded way and have it be faster. I worry about deadlocks and other things that might not be anticipated. Did you profile this to make sure the threading is a huge overhead? What exact parts are holding up things?

include/lldb/Core/Connection.h

202

return "lldb::IOObjectSP()" instead of nullptr.

tools/lldb-server/lldb-gdbserver.cpp

667

Why do you need to pass "mainloop" if it is already in gdb_server?

[clayborg]

The design is very signal centric right now. Not sure if that will bode well for windows.

What are the signals supposed to be for? Just handling "SIGHUP" and "SIGINT"? If so, you need to make sure no one does any real work inside any of these functions because it isn't safe to do 95% of any function calls in a signal handler function. It would be better to just create a lldb_private::Event into your loop that can be handled on the up and up and the signal handler would just post an event to the queue for the MainLoop to consume. Then you can do anything you want when you get the event because you aren't handling it from a signal handler callback. But of course this is usually the problem: something has locked up your lldb-server and you want to interrupt it. If the MainLoop is handling a packet that is deadlocked somehow, you will never be able to consume the event you just created for SIGHUP and you won't be able to cancel/kill/disconnect...

Are the signal handlers designed to handle the signals received from the program that is being debugged? If so this would be better served up using StopInfoSP objects for specific threads.

I look forward to seeing your responses.

[amccarth]

Assuming I've understood correctly ...

I don't think any approach will completely eliminate the need for a separate thread on Windows to run the debug loop (at least, not without an inefficient hack like polling for events).

On Windows, debug events are special--they don't work like other types of asynchronous events, so you can't just wait for them like you might wait for an asynchronous i/o or for some handle to become signaled. Nor is there a hybrid wait function (like MsgWaitForMultipleObjects that lets you wait for a either a windows message or a handle to become signaled). As far as I know, there's just WaitForDebugEvent, which only waits for debug events (and imposes some restrictions on other things that can be done in that thread). You could poll by waiting with a 0 timeout, but that would be an inefficient hack, so that's a non-starter.

But that doesn't rule out this MainLoop abstraction. A simple debug loop in a separate thread could translate raw Windows debugging events into events that could be detected by MainLoop. So if MainLoop helps on other platforms, the Windows implementation could be made to work with this model, probably without a significant difference in performance or code complexity.

include/lldb/Host/posix/MainLoopPosix.h

23

s/Montitoring/Monitoring/

24

s/recieves/receives/

81

What sorts of signals might this mechanism be used for?

Be aware that Windows defines fewer signals than POSIX.

include/lldb/Host/windows/MainLoopWindows.h

21

Is there a particular reason you didn't defined a common interface in a base class that both MainLoopWindows and MainLoopPosix would derive from? Is it concern over the performance of virtual function calls? Or are you expecting different platforms to provide significantly different public interfaces?

[labath]

Thank you for the comments. My (rather lengthy) replies are below.

In D11066#201959, @clayborg wrote:

Since there are going to require multiple patches to make this work it might be best to do this in a branch. I worry about being able to handle everything in a single threaded way and have it be faster. I worry about deadlocks and other things that might not be anticipated. Did you profile this to make sure the threading is a huge overhead? What exact parts are holding up things?

It is going to be a series of patches, but it's not going to be that big, since I have already done a big thread cleanup inside NativeProcessLinux. llgs now consists of three threads
a) network communication thread
b) inferior monitoring thread
c) stdio forwarding thread
This commit makes (a) use the mainloop abstraction. I expect I will need two more to port over (b) and (c), and then maybe some small cleanup commits. I think it will be easier to review this if I keep the work on the main branch, and I believe it will work without introducing regressions.
( Just to make things clear, I do not intend to do anything with the client threads here. The IOHandler thing i suggest below is merely an abstraction switch, but all the thread interactions remain the same. I do feel that the client has too many threads, but that is a completely different topic. :) )

I already have a butchered version of llgs, which runs on a single thread. I have noticed no deadlocks and my benchmarks indicate that the round-trip time for the qThreadStopInfo packet has gone down from 7.8 to 5.4 ms (these numbers include network latency). For comparison switching to jThreadsInfo did not speed things up at all, it merely added up the individual round-trip (but I have some ideas on how to improve that as well). The threading is an overhead for us since we have to perform all debug operations on a designated thread. This involves a lot of back-and-forth when we are responding to packets since our debug operations are quite small-grained (e.g. "read this register"). Now we could alleviate this by making the operations more coarse-grained ("read all GPRs"), but I think we would hit this wall sooner or later. As I understand it, debugserver is also single-threaded for performance reasons, right?

This is why I think it would be better to get rid of the thread ping-pong first, and then profiling the remaining bottle-necks (of which there are many, I am sure) will become easier.

What are the signals supposed to be for? Just handling "SIGHUP" and "SIGINT"? If so, you need to make sure no one does any real work inside any of these functions because it isn't safe to do 95% of any function calls in a signal handler function.

Currently, the signal handler just sets a flag. This flag will be checked in the Run() function and the appropriate callback invoked if it is set. NativeProcessLinux will install a callback for SIGCHLD and will retrieve all the info it needs when it gets called.

If the MainLoop is handling a packet that is deadlocked somehow, you will never be able to consume the event you just created for SIGHUP and you won't be able to cancel/kill/disconnect...

SIGHUP is not my main motivation for this, but I have ported it while I was at it. SIGHUP is used as a request for graceful termination, so checking for the flag after packet handling completes is a good choice I think (and this is what the current implementation is doing). If the process is locked up, then we are unlikely to be able to terminate gracefully, so sending a signal which will kill us outright (SIGTERM or any other unhandled signal) is as good solution as any.

In D11066#202473, @amccarth wrote:

But that doesn't rule out this MainLoop abstraction. A simple debug loop in a separate thread could translate raw Windows debugging events into events that could be detected by MainLoop. So if MainLoop helps on other platforms, the Windows implementation could be made to work with this model, probably without a significant difference in performance or code complexity.

I don't think the current implementation of ProcessWindows needs to worry about the MainLoop (see the comment about IOHandler on why i am involving you). However, if windows ever moves to the remote debugging model then we may need to do something like you suggest.

include/lldb/Host/posix/MainLoopPosix.h

81

The main use for me now is the receipt of SIGCHLD (which signals that there is something interesting happening in the inferior). On linux we can use this to multiplex inferior events and network communication on a single thread.

I know that on windows, signals aren't really a thing and if we don't need them there, MainLoopWindows does not even have to declare this method. On the other hand, I can imagine implementing a MLW::RegisterWindowsSpecificHandle, which would then multiplex socket I/O with some other events using whatever method is right for that on windows. Or maybe it does not need additional methods and everything that we need to wait for can be represented with IOObjects.

The main value of this abstraction I see for windows would be for things like IOHandlerProcessSTDIO, which is disabled for windows, because there you cannot select() over non-socket file descriptors. I imagine the code there can be replaced by something like

void IOHandlerProcessSTDIO::Run() {
  MainLoop::ReadHandleUP = m_mainloop.RegisterReadObject(m_read_file,
    [] { do_whatever_you_need_to_do_when_data_is_available(); } );
  m_mainloop.Run();
}
void IOHandlerProcessSTDIO::Cancel() {
  m_mainloop.RequestTermination();
}

(for this we would need to make RequestTermination be safe to execute from another thread, which I haven't done yet, since I don't need it, but it can be easily added)

include/lldb/Host/windows/MainLoopWindows.h

21

I saw the typedef pattern in LockFile.h, but I did not notice that there actually is a LockFileBase that they inherit from. I will add a Base class for this.

tools/lldb-server/lldb-gdbserver.cpp

667

I have refactored this to avoid passing the parameter. Main loop is now run directly from the main function. (mainloop is in gdb_server, because the NativeProcessLinux will need to register additional events when it get's spawned).

[labath]

• Address review comments

[clayborg]

I am fine with this part of the patch since it doesn't introduce any changes and most of the threading issues seem to be with the ProcessMonitor if I understood your comments correctly.

To clarify how debugserver works: It has 3 threads:

• main thread that just does read packet, process packet, write packet, loop
• exception thread for catching exceptions from the debugged process
• reap thread to read the unix process

[ovyalov]

Minor comments.

include/lldb/Host/posix/MainLoopPosix.h

92

s/int/IOObject::WaitableHandle ?

source/Host/posix/MainLoopPosix.cpp

109

Could add a check for iterator != m_signals.end() ?

172

Check for termination flag set here?
It seems no need to read from sockets if signal handlers requested termination?

tools/lldb-server/lldb-gdbserver.cpp

411

Could you log if error is returned?

470

ditto.

[labath]

source/Host/posix/MainLoopPosix.cpp

172

Ok, makes sense. I will add the check after every callback then, because by extension, there is no need to read from the second socket (if any) if the first socket requested termination.

tools/lldb-server/lldb-gdbserver.cpp

411

Done. I've also merged the two branches a bit.

include/lldb/Core/Connection.h

public:
     /// operation).
     ///
     /// @return
     ///     Returns true is the interrupt request was sucessful.
     //------------------------------------------------------------------
     virtual bool
     InterruptRead() = 0;
 
+    //------------------------------------------------------------------
+    /// Returns the underlying IOObject used by the Connection.
+    ///
+    /// The IOObject can be used to wait for data to become available
+    /// on the connection. If the Connection does not use IOObjects (and
+    /// hence does not support waiting) this function should return a
+    /// null pointer.
+    ///
+    /// @return
+    ///     The underlying IOObject used for reading.
+    //------------------------------------------------------------------
+    virtual lldb::IOObjectSP
+    GetReadObject() { return nullptr; }
+
 private:
     //------------------------------------------------------------------
     // For Connection only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (Connection);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_Connection_h_

include/lldb/Host/MainLoop.h

+//===-- MainLoop.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_MainLoop_h_
+#define lldb_Host_MainLoop_h_
+
+#ifdef _WIN32
+#include "lldb/Host/windows/MainLoopWindows.h"
+namespace lldb_private
+{
+typedef MainLoopWindows MainLoop;
+}
+#else
+#include "lldb/Host/posix/MainLoopPosix.h"
+namespace lldb_private
+{
+typedef MainLoopPosix MainLoop;
+}
+#endif
+
+#endif // lldb_Host_MainLoop_h_

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

public:
 
     std::string GetURI() override;
 
     lldb::ConnectionStatus BytesAvailable(uint32_t timeout_usec, Error *error_ptr);
 
     bool InterruptRead() override;
 
     lldb::IOObjectSP
-    GetReadObject()
-    {
-        return m_read_sp;
-    }
-    const lldb::IOObjectSP
-    GetReadObject() const
+    GetReadObject() override
     {
         return m_read_sp;
     }
 
     uint16_t GetListeningPort(uint32_t timeout_sec);
 
     bool GetChildProcessesInherit() const;
     void SetChildProcessesInherit(bool child_processes_inherit);

include/lldb/Host/posix/MainLoopPosix.h

+//===-- MainLoopPosix.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_posix_MainLoopPosix_h_
+#define lldb_Host_posix_MainLoopPosix_h_
+
+#include <functional>
+
+#include "llvm/ADT/DenseMap.h"
+#include "lldb/Host/IOObject.h"
+
+namespace lldb_private {
+
+// The purpose of this class is to enable multiplexed processing of data from different sources
+// without resorting to multi-threading. Clients can register IOObjects, which will be monitored
+// using select(), and when they become readable, the specified callback will be invoked.
+// Montitoring for writability is not supported, but can be easily added if needed. Additionally,
+// this class supports invoking a callback when the process recieves a given signal.
+//
+// The Register*** functions return a handle, which controls the duration of the monitoring. When
+// this handle is destroyed, the callback is deregistered.
+//
+// Since this class is primarily intended to be used for single-threaded processing, it does not
+// attempt to perform any internal synchronisation and any concurrent accesses must be protected
+// externally. However, it is perfectly legitimate to have more than one instance of this class
+// running on separate threads, or even a single thread (with some limitations on signal
+// monitoring).
+class MainLoopPosix
+{
+public:
+    class ReadHandle
+    {
+    public:
+        ~ReadHandle() { m_mainloop.UnregisterReadObject(m_object_sp); }
+
+    private:
+        ReadHandle(MainLoopPosix &mainloop, const lldb::IOObjectSP &object_sp)
+            : m_mainloop(mainloop), m_object_sp(object_sp)
+        { }
+
+        MainLoopPosix &m_mainloop;
+        lldb::IOObjectSP m_object_sp;
+
+        friend class MainLoopPosix;
+        DISALLOW_COPY_AND_ASSIGN(ReadHandle);
+    };
+    typedef std::unique_ptr<ReadHandle> ReadHandleUP;
+
+    class SignalHandle
+    {
+    public:
+        ~SignalHandle() { m_mainloop.UnregisterSignal(m_signo); }
+
+    private:
+        SignalHandle(MainLoopPosix &mainloop, int signo) : m_mainloop(mainloop), m_signo(signo) { }
+
+        MainLoopPosix &m_mainloop;
+        int m_signo;
+
+        friend class MainLoopPosix;
+        DISALLOW_COPY_AND_ASSIGN(SignalHandle);
+    };
+    typedef std::unique_ptr<SignalHandle> SignalHandleUP;
+
+    typedef std::function<void(MainLoopPosix &)> Callback;
+
+    ReadHandleUP
+    RegisterReadObject(const lldb::IOObjectSP &object_sp, const Callback &callback, Error &error);
+
+    // Listening for signals from multiple MainLoopPosix instances is perfectly safe as long as they
+    // don't try to listen for the same signal. The callback function is invoked when the control
+    // returns to the Run() function, not when the hander is executed. This means that you can
+    // treat the callback as a normal function and perform things which would not be safe in a
+    // signal handler. However, since the callback is not invoked synchronously, you cannot use
+    // this mechanism to handle SIGSEGV and the like.
+    SignalHandleUP
+    RegisterSignal(int signo, const Callback &callback, Error &error);
+
+    // Waits for registered events and invoke the proper callbacks. Returns when all callbacks
+    // deregister themselves or when someone requests termination.
+    Error
+    Run();
+
+    // Requests the exit of the Run() function. This should only be performed from a callback.
+    // Do not attempt to terminate the processing from another thread.
+    void
+    RequestTermination() { m_terminate_request = true; }
+
+    ~MainLoopPosix();
+
+private:
+    struct SignalInfo
+    {
+        Callback callback;
+        struct sigaction old_action;
+        bool was_blocked : 1;
+    };
+
+    llvm::DenseMap<int, Callback> m_read_fds;
+    llvm::DenseMap<int, SignalInfo> m_signals;
+    bool m_terminate_request : 1;
+
+    void
+    UnregisterReadObject(const lldb::IOObjectSP &object_sp);
+
+    void
+    UnregisterSignal(int signo);
+};
+
+} // namespace lldb_private
+
+
+#endif // lldb_Host_posix_MainLoopPosix_h_
+

include/lldb/Host/windows/MainLoopWindows.h

+//===-- MainLoopWindows.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_posix_MainLoopWindows_h_
+#define lldb_Host_posix_MainLoopWindows_h_
+
+#include <functional>
+
+#include "llvm/Support/ErrorHandling.h"
+
+#include "lldb/Host/IOObject.h"
+
+namespace lldb_private {
+
+class MainLoopWindows
+{
+public:
+    class ReadHandle
+    {
+    };
+    typedef std::unique_ptr<ReadHandle> ReadHandleUP;
+
+    typedef std::function<void(MainLoopWindows &)> Callback;
+
+    ReadHandleUP
+    RegisterReadObject(const lldb::IOObjectSP &object_sp, const Callback &callback, Error &error)
+    { llvm_unreachable("Not implemented"); }
+
+    Error
+    Run() { llvm_unreachable("Not implemented"); }
+
+    void RequestTermination() { llvm_unreachable("Not implemented"); }
+};
+
+} // namespace lldb_private
+
+
+#endif // lldb_Host_posix_MainLoopWindows_h_
+

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     26F006561B4DD86700B872E5 /* DynamicLoaderWindowsDYLD.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F006541B4DD86700B872E5 /* DynamicLoaderWindowsDYLD.cpp */; };
     26F4A21C13FBA31A0064B613 /* ThreadMemory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F4A21A13FBA31A0064B613 /* ThreadMemory.cpp */; };
     26F5C27710F3D9E4009D5894 /* Driver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F5C27310F3D9E4009D5894 /* Driver.cpp */; };
     26F5C32D10F3DFDD009D5894 /* libtermcap.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 26F5C32B10F3DFDD009D5894 /* libtermcap.dylib */; };
     26F73062139D8FDB00FD51C7 /* History.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26F73061139D8FDB00FD51C7 /* History.cpp */; };
     26FFC19914FC072100087D58 /* AuxVector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19314FC072100087D58 /* AuxVector.cpp */; };
     26FFC19B14FC072100087D58 /* DYLDRendezvous.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */; };
     26FFC19D14FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */; };
+    30DED5DE1B4ECB49004CC508 /* MainLoopPosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 30DED5DC1B4ECB17004CC508 /* MainLoopPosix.cpp */; };
     332CCB181AFF41620034D4C4 /* SBLanguageRuntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 3392EBB71AFF402200858B9F /* SBLanguageRuntime.h */; settings = {ATTRIBUTES = (Public, ); }; };
     33E5E8421A672A240024ED68 /* StringConvert.cpp in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33E5E8411A672A240024ED68 /* StringConvert.cpp */; };
     33E5E8461A6736D30024ED68 /* StringConvert.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 33E5E8451A6736D30024ED68 /* StringConvert.h */; };
     33E5E8471A674FB60024ED68 /* StringConvert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 33E5E8411A672A240024ED68 /* StringConvert.cpp */; };
     3F8160A61AB9F7DD001DA9DF /* Logging.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3F8160A51AB9F7DD001DA9DF /* Logging.cpp */; };
     3F8169191ABA2419001DA9DF /* ConvertEnum.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3F8169171ABA2419001DA9DF /* ConvertEnum.cpp */; };
     3F81691A1ABA2419001DA9DF /* NameMatches.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3F8169181ABA2419001DA9DF /* NameMatches.cpp */; };
     3F81692C1ABB7A1E001DA9DF /* SystemInitializerFull.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3F81692A1ABB7A16001DA9DF /* SystemInitializerFull.cpp */; };

     26FA4315130103F400E71120 /* FileSpec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FileSpec.h; path = include/lldb/Host/FileSpec.h; sourceTree = "<group>"; };
     26FA43171301048600E71120 /* FileSpec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = FileSpec.cpp; sourceTree = "<group>"; };
     26FFC19314FC072100087D58 /* AuxVector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AuxVector.cpp; sourceTree = "<group>"; };
     26FFC19414FC072100087D58 /* AuxVector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AuxVector.h; sourceTree = "<group>"; };
     26FFC19514FC072100087D58 /* DYLDRendezvous.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DYLDRendezvous.cpp; sourceTree = "<group>"; };
     26FFC19614FC072100087D58 /* DYLDRendezvous.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DYLDRendezvous.h; sourceTree = "<group>"; };
     26FFC19714FC072100087D58 /* DynamicLoaderPOSIXDYLD.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DynamicLoaderPOSIXDYLD.cpp; sourceTree = "<group>"; };
     26FFC19814FC072100087D58 /* DynamicLoaderPOSIXDYLD.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DynamicLoaderPOSIXDYLD.h; sourceTree = "<group>"; };
+    30DED5DC1B4ECB17004CC508 /* MainLoopPosix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MainLoopPosix.cpp; sourceTree = "<group>"; };
     33064C991A5C7A330033D415 /* UriParser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = UriParser.cpp; path = source/Utility/UriParser.cpp; sourceTree = "<group>"; };
     33064C9B1A5C7A490033D415 /* UriParser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = UriParser.h; path = source/Utility/UriParser.h; sourceTree = "<group>"; };
     3392EBB71AFF402200858B9F /* SBLanguageRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBLanguageRuntime.h; path = include/lldb/API/SBLanguageRuntime.h; sourceTree = "<group>"; };
     33E5E8411A672A240024ED68 /* StringConvert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringConvert.cpp; sourceTree = "<group>"; };
     33E5E8451A6736D30024ED68 /* StringConvert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StringConvert.h; path = include/lldb/Host/StringConvert.h; sourceTree = SOURCE_ROOT; };
     3F5E8AF31A40D4A500A73232 /* PipeBase.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = PipeBase.h; path = include/lldb/Host/PipeBase.h; sourceTree = "<group>"; };
     3F8160A51AB9F7DD001DA9DF /* Logging.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = Logging.cpp; path = source/Core/Logging.cpp; sourceTree = "<group>"; };
     3F8160A71AB9F809001DA9DF /* Logging.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Logging.h; path = include/lldb/Core/Logging.h; sourceTree = "<group>"; };
3F8169261ABB73C1001DA9DF /* Initialization */ = {
       );
       name = Initialization;
       sourceTree = "<group>";
     };
     3FDFDDC4199D37BE009756A7 /* posix */ = {
       isa = PBXGroup;
       children = (
         255EFF751AFABA950069F277 /* LockFilePosix.cpp */,
+        30DED5DC1B4ECB17004CC508 /* MainLoopPosix.cpp */,
         AFDFDFD019E34D3400EAE509 /* ConnectionFileDescriptorPosix.cpp */,
         3FDFDDC5199D37ED009756A7 /* FileSystem.cpp */,
         3FDFE53019A292F0009756A7 /* HostInfoPosix.cpp */,
         3FDFE53219A29304009756A7 /* HostInfoPosix.h */,
         3FDFE56A19AF9C44009756A7 /* HostProcessPosix.cpp */,
         3FDFE56E19AF9C5A009756A7 /* HostProcessPosix.h */,
         3FDFE56B19AF9C44009756A7 /* HostThreadPosix.cpp */,
         3FDFE56F19AF9C5A009756A7 /* HostThreadPosix.h */,
2690CD131A6DC0D000E717C8 /* Sources */ = {
         2669423D1A6DC2AC0063BE93 /* MIDriver.cpp in Sources */,
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
     26DC6A0D1337FE6900FF7998 /* Sources */ = {
       isa = PBXSourcesBuildPhase;
       buildActionMask = 2147483647;
       files = (
+        30DED5DE1B4ECB49004CC508 /* MainLoopPosix.cpp in Sources */,
         E769331C1A94D15400C73337 /* lldb-gdbserver.cpp in Sources */,
         26DC6A1D1337FECA00FF7998 /* lldb-platform.cpp in Sources */,
         E769331E1A94D18100C73337 /* lldb-server.cpp in Sources */,
       );
       runOnlyForDeploymentPostprocessing = 0;
     };
     26F5C26710F3D9A4009D5894 /* Sources */ = {
       isa = PBXSourcesBuildPhase;

source/Host/CMakeLists.txt

add_host_subdirectory(windows
     )
 else()
   add_host_subdirectory(posix
     posix/FileSystem.cpp
     posix/HostInfoPosix.cpp
     posix/HostProcessPosix.cpp
     posix/HostThreadPosix.cpp
     posix/LockFilePosix.cpp
+    posix/MainLoopPosix.cpp
     posix/PipePosix.cpp
     )
 
   if (NOT __ANDROID_NDK__)
     add_host_subdirectory(posix
       posix/ProcessLauncherPosix.cpp
       )
   endif()

source/Host/posix/MainLoopPosix.cpp

+//===-- MainLoopPosix.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/posix/MainLoopPosix.h"
+
+#include <vector>
+
+#include "lldb/Core/Error.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+static sig_atomic_t g_signal_flags[NSIG];
+
+static void
+SignalHandler(int signo, siginfo_t *info, void *)
+{
+    assert(signo < NSIG);
+    g_signal_flags[signo] = 1;
+}
+
+
+MainLoopPosix::~MainLoopPosix()
+{
+    assert(m_read_fds.size() == 0);
+    assert(m_signals.size() == 0);
+}
+
+MainLoopPosix::ReadHandleUP
+MainLoopPosix::RegisterReadObject(const IOObjectSP &object_sp, const Callback &callback, Error &error)
+{
+    if (!object_sp || !object_sp->IsValid())
+    {
+        error.SetErrorString("IO object is not valid.");
+        return nullptr;
+    }
+
+    const bool inserted = m_read_fds.insert({object_sp->GetWaitableHandle(), callback}).second;
+    if (! inserted)
+    {
+        error.SetErrorStringWithFormat("File descriptor %d already monitored.",
+                object_sp->GetWaitableHandle());
+        return nullptr;
+    }
+
+    return ReadHandleUP(new ReadHandle(*this, object_sp));
+}
+
+// We shall block the signal, then install the signal handler. The signal will be unblocked in
+// the Run() function to check for signal delivery.
+MainLoopPosix::SignalHandleUP
+MainLoopPosix::RegisterSignal(int signo, const Callback &callback, Error &error)
+{
+    if (m_signals.find(signo) != m_signals.end())
+    {
+        error.SetErrorStringWithFormat("Signal %d already monitored.", signo);
+        return nullptr;
+    }
+
+    SignalInfo info;
+    info.callback = callback;
+    struct sigaction new_action;
+    new_action.sa_sigaction = &SignalHandler;
+    new_action.sa_flags = SA_SIGINFO;
+    sigemptyset(&new_action.sa_mask);
+    sigaddset(&new_action.sa_mask, signo);
+
+    sigset_t old_set;
+    if (int ret = pthread_sigmask(SIG_BLOCK, &new_action.sa_mask, &old_set))
+    {
+        error.SetErrorStringWithFormat("pthread_sigmask failed with error %d\n", ret);
+        return nullptr;
+    }
+
+    info.was_blocked = sigismember(&old_set, signo);
+    if (sigaction(signo, &new_action, &info.old_action) == -1)
+    {
+        error.SetErrorToErrno();
+        if (!info.was_blocked)
+            pthread_sigmask(SIG_UNBLOCK, &new_action.sa_mask, nullptr);
+        return nullptr;
+    }
+
+    m_signals.insert({signo, info});
+    g_signal_flags[signo] = 0;
+
+    return SignalHandleUP(new SignalHandle(*this, signo));
+}
+
+void
+MainLoopPosix::UnregisterReadObject(const lldb::IOObjectSP &object_sp)
+{
+    bool erased = m_read_fds.erase(object_sp->GetWaitableHandle());
+    (void) erased;
+    assert(erased);
+}
+
+void
+MainLoopPosix::UnregisterSignal(int signo)
+{
+    // We undo the actions of RegisterSignal on a best-effort basis.
+    auto it = m_signals.find(signo);
+
+    sigaction(signo, &it->second.old_action, nullptr);
+
+    sigset_t set;
+    sigemptyset(&set);
+    sigaddset(&set, signo);
+    pthread_sigmask(it->second.was_blocked ? SIG_BLOCK : SIG_UNBLOCK, &set, nullptr);
+
+    m_signals.erase(it);
+}
+
+Error
+MainLoopPosix::Run()
+{
+    std::vector<int> signals;
+    sigset_t sigmask;
+    std::vector<int> read_fds;
+    fd_set read_fd_set;
+    m_terminate_request = false;
+
+    // run until termination or until we run out of things to listen to
+    while (! m_terminate_request && (!m_read_fds.empty() || !m_signals.empty()))
+    {
+        // To avoid problems with callbacks changing the things we're supposed to listen to, we
+        // will store the *real* list of events separately.
+        signals.clear();
+        read_fds.clear();
+        FD_ZERO(&read_fd_set);
+        int nfds = 0;
+
+        if (int ret = pthread_sigmask(SIG_SETMASK, nullptr, &sigmask))
+            return Error("pthread_sigmask failed with error %d\n", ret);
+
+        for (const auto &fd: m_read_fds)
+        {
+            read_fds.push_back(fd.first);
+            FD_SET(fd.first, &read_fd_set);
+            nfds = std::max(nfds, fd.first+1);
+        }
+
+        for (const auto &sig: m_signals)
+        {
+            signals.push_back(sig.first);
+            sigdelset(&sigmask, sig.first);
+        }
+
+        if (pselect(nfds, &read_fd_set, nullptr, nullptr, nullptr, &sigmask) == -1 && errno != EINTR)
+            return Error(errno, eErrorTypePOSIX);
+
+        for (int sig: signals)
+        {
+            if (g_signal_flags[sig] == 0)
+                continue; // No signal
+            g_signal_flags[sig] = 0;
+
+            auto it = m_signals.find(sig);
+            if (it == m_signals.end())
+                continue; // Signal must have gotten unregistered in the meantime
+
+            it->second.callback(*this); // Do the work
+        }
+
+        for (int fd: read_fds)
+        {
+            if (!FD_ISSET(fd, &read_fd_set))
+                continue; // Not ready
+
+            auto it = m_read_fds.find(fd);
+            if (it == m_read_fds.end())
+                continue; // File descriptor must have gotten unregistered in the meantime
+
+            it->second(*this); // Do the work
+        }
+    }
+    return Error();
+}
+
+

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h

public:
     GetPacketAndSendResponse (uint32_t timeout_usec,
                               Error &error,
                               bool &interrupt, 
                               bool &quit);
 
     // After connecting, do a little handshake with the client to make sure
     // we are at least communicating
     bool
-    HandshakeWithClient (Error *error_ptr);
+    HandshakeWithClient ();
 
 protected:
     std::map<StringExtractorGDBRemote::ServerPacketType, PacketHandler> m_packet_handlers;
     bool m_exit_now; // use in asynchronous handling to indicate process should exit.
 
     PacketResult
     SendUnimplementedResponse (const char *packet);
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendOKResponse ()
 {
     return SendPacketNoLock ("OK", 2);
 }
 
 bool
-GDBRemoteCommunicationServer::HandshakeWithClient(Error *error_ptr)
+GDBRemoteCommunicationServer::HandshakeWithClient()
 {
     return GetAck() == PacketResult::Success;
 }

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

 // C++ Includes
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/Communication.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
+#include "lldb/Host/MainLoop.h"
 
 // Project includes
 #include "GDBRemoteCommunicationServerCommon.h"
 
 class StringExtractorGDBRemote;
 
 namespace lldb_private {
+
 namespace process_gdb_remote {
 
 class ProcessGDBRemote;
 
 class GDBRemoteCommunicationServerLLGS :
     public GDBRemoteCommunicationServerCommon,
     public NativeProcessProtocol::NativeDelegate
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp);
+    GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP& platform_sp, MainLoop &mainloop);
 
     virtual
     ~GDBRemoteCommunicationServerLLGS();
 
     //------------------------------------------------------------------
     /// Specify the program to launch and its arguments.
     ///
     /// @param[in] args
public:
     InitializeDelegate (NativeProcessProtocol *process) override;
 
     void
     ProcessStateChanged (NativeProcessProtocol *process, lldb::StateType state) override;
 
     void
     DidExec (NativeProcessProtocol *process) override;
 
+    Error
+    InitializeConnection (std::unique_ptr<Connection> &&connection);
+
 protected:
     lldb::PlatformSP m_platform_sp;
-    lldb::thread_t m_async_thread;
+    MainLoop &m_mainloop;
+    MainLoop::ReadHandleUP m_read_handle_up;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
     Mutex m_debugged_process_mutex;
     NativeProcessProtocolSP m_debugged_process_sp;
     Communication m_stdio_communication;
     lldb::StateType m_inferior_prev_state;
     lldb::DataBufferSP m_active_auxv_buffer_sp;
     Mutex m_saved_registers_mutex;
     std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
     uint32_t m_next_saved_registers_id;
+    bool m_handshake_completed : 1;
 
     PacketResult
     SendONotification (const char *buffer, uint32_t len);
 
     PacketResult
     SendWResponse (NativeProcessProtocol *process);
 
     PacketResult
private:
     MaybeCloseInferiorTerminalConnection ();
 
     void
     ClearProcessSpecificData ();
 
     void
     RegisterPacketHandlers ();
 
+    void
+    DataAvailableCallback ();
+
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationServerLLGS only
     //------------------------------------------------------------------
     DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationServerLLGS);
 };
 
 } // namespace process_gdb_remote
 } // namespace lldb_private
 
 #endif  // liblldb_GDBRemoteCommunicationServerLLGS_h_

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

enum GDBRemoteServerError
         eErrorExitStatus
     };
 }
 
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerLLGS constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
-        const lldb::PlatformSP& platform_sp) :
+        const lldb::PlatformSP& platform_sp,
+        MainLoop &mainloop) :
     GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
     m_platform_sp (platform_sp),
-    m_async_thread (LLDB_INVALID_HOST_THREAD),
+    m_mainloop (mainloop),
     m_current_tid (LLDB_INVALID_THREAD_ID),
     m_continue_tid (LLDB_INVALID_THREAD_ID),
     m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
     m_debugged_process_sp (),
     m_stdio_communication ("process.stdio"),
     m_inferior_prev_state (StateType::eStateInvalid),
     m_active_auxv_buffer_sp (),
     m_saved_registers_mutex (),
     m_saved_registers_map (),
-    m_next_saved_registers_id (1)
+    m_next_saved_registers_id (1),
+    m_handshake_completed (false)
 {
     assert(platform_sp);
     RegisterPacketHandlers();
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------

 }
 
 void
 GDBRemoteCommunicationServerLLGS::DidExec (NativeProcessProtocol *process)
 {
     ClearProcessSpecificData ();
 }
 
+void
+GDBRemoteCommunicationServerLLGS::DataAvailableCallback ()
+{
+    Log *log (GetLogIfAnyCategoriesSet(GDBR_LOG_COMM));
+
+    if (! m_handshake_completed)
+    {
+        if (! HandshakeWithClient())
+        {
+            if(log)
+                log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with client failed, exiting",
+                        __FUNCTION__);
+            m_read_handle_up.reset();
+            m_mainloop.RequestTermination();
+            return;
+        }
+        m_handshake_completed = true;
+    }
+
+    bool interrupt = false;
+    bool done = false;
+    Error error;
+    while (true)
+    {
+        const PacketResult result = GetPacketAndSendResponse (0, error, interrupt, done);
+        if (result == PacketResult::ErrorReplyTimeout)
+            break; // No more packets in the queue
+
+        if ((result != PacketResult::Success))
+        {
+            if(log)
+                log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet failed: %s",
+                        __FUNCTION__, error.AsCString());
+            m_read_handle_up.reset();
+            m_mainloop.RequestTermination();
+            break;
+        }
+    }
+}
+
+Error
+GDBRemoteCommunicationServerLLGS::InitializeConnection (std::unique_ptr<Connection> &&connection)
+{
+    IOObjectSP read_object_sp = connection->GetReadObject();
+    GDBRemoteCommunicationServer::SetConnection(connection.release());
+
+    Error error;
+    m_read_handle_up = m_mainloop.RegisterReadObject(read_object_sp,
+            [this] (MainLoop &) { DataAvailableCallback(); }, error);
+    return error;
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::SendONotification (const char *buffer, uint32_t len)
 {
     if ((buffer == nullptr) || (len == 0))
     {
         // Nothing to send.
         return PacketResult::Success;
     }

tools/lldb-server/lldb-gdbserver.cpp

signal_handler(int signo)
     if (log)
         log->Printf ("lldb-server:%s received signal %d", __FUNCTION__, signo);
 
     switch (signo)
     {
     case SIGPIPE:
         g_sigpipe_received = 1;
         break;
-    case SIGHUP:
-        ++g_sighup_received_count;
+    }
+}
+
+static void
+sighup_handler(MainLoop &mainloop)
+{
 
-        // For now, swallow SIGHUP.
-        if (log)
-            log->Printf ("lldb-server:%s swallowing SIGHUP (receive count=%d)", __FUNCTION__, g_sighup_received_count);
-        signal (SIGHUP, signal_handler);
-        break;
-    }
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    if (g_sighup_received_count >= 2)
+        mainloop.RequestTermination();
 }
 #endif // #ifndef _WIN32
 
 static void
 display_usage (const char *progname, const char* subcommand)
 {
     fprintf(stderr, "Usage:\n  %s %s "
             "[--log-file log-file-name] "
#if defined(_WIN32)
     return Error("Unnamed pipes are not supported on Windows.");
 #else
     Pipe port_pipe{Pipe::kInvalidDescriptor, unnamed_pipe_fd};
     return WritePortToPipe(port_pipe, port);
 #endif
 }
 
 void
-ConnectToRemote(GDBRemoteCommunicationServerLLGS &gdb_server,
+ConnectToRemote(MainLoop &mainloop, GDBRemoteCommunicationServerLLGS &gdb_server,
         bool reverse_connect, const char *const host_and_port,
         const char *const progname, const char *const subcommand,
         const char *const named_pipe_path, int unnamed_pipe_fd)
 {
     Error error;
 
     if (host_and_port && host_and_port[0])
     {
if (host_and_port && host_and_port[0])
             }
 
             // Build the connection string.
             char connection_url[512];
             snprintf(connection_url, sizeof(connection_url), "connect://%s", final_host_and_port.c_str ());
 
             // Create the connection.
             std::unique_ptr<ConnectionFileDescriptor> connection_up (new ConnectionFileDescriptor ());
-            connection_up.reset (new ConnectionFileDescriptor ());
             auto connection_result = connection_up->Connect (connection_url, &error);
             if (connection_result != eConnectionStatusSuccess)
             {
                 fprintf (stderr, "error: failed to connect to client at '%s' (connection status: %d)", connection_url, static_cast<int> (connection_result));
                 exit (-1);
             }
             if (error.Fail ())
             {
                 fprintf (stderr, "error: failed to connect to client at '%s': %s", connection_url, error.AsCString ());
                 exit (-1);
             }
 
             // We're connected.
             printf ("Connection established.\n");
-            gdb_server.SetConnection (connection_up.release());
+            gdb_server.InitializeConnection (std::move(connection_up));
         }
         else
         {
             // llgs will listen for connections on the given port from the given address.
             // Start the listener on a new thread.  We need to do this so we can resolve the
             // bound listener port.
             StartListenThread(connection_host.c_str (), static_cast<uint16_t> (connection_portno));
             printf ("Listening to port %s for a connection from %s...\n", connection_port.c_str (), connection_host.c_str ());
if (host_and_port && host_and_port[0])
                 display_usage (progname, subcommand);
                 exit (1);
             }
 
             // Ensure we connected.
             if (s_listen_connection_up)
             {
                 printf ("Connection established '%s'\n", s_listen_connection_up->GetURI().c_str());
-                gdb_server.SetConnection (s_listen_connection_up.release());
+                gdb_server.InitializeConnection (std::move(s_listen_connection_up));
             }
             else
             {
                 fprintf (stderr, "failed to connect to '%s': %s\n", final_host_and_port.c_str (), error.AsCString ());
                 display_usage (progname, subcommand);
                 exit (1);
             }
         }
     }
 
     if (gdb_server.IsConnected())
     {
-        // After we connected, we need to get an initial ack from...
-        if (gdb_server.HandshakeWithClient(&error))
-        {
-            // We'll use a half a second timeout interval so that an exit conditions can
-            // be checked that often.
-            const uint32_t TIMEOUT_USEC = 500000;
-
-            bool interrupt = false;
-            bool done = false;
-            while (!interrupt && !done && (g_sighup_received_count < 2))
-            {
-                const GDBRemoteCommunication::PacketResult result = gdb_server.GetPacketAndSendResponse (TIMEOUT_USEC, error, interrupt, done);
-                if ((result != GDBRemoteCommunication::PacketResult::Success) &&
-                    (result != GDBRemoteCommunication::PacketResult::ErrorReplyTimeout))
-                {
-                    // We're bailing out - we only support successful handling and timeouts.
-                    fprintf(stderr, "leaving packet loop due to PacketResult %d\n", result);
-                    break;
-                }
-            }
-
-            if (error.Fail())
-            {
-                fprintf(stderr, "error: %s\n", error.AsCString());
-            }
-        }
-        else
-        {
-            fprintf(stderr, "error: handshake with client failed\n");
-        }
+        mainloop.Run();
     }
     else
     {
         fprintf (stderr, "no connection information provided, unable to run\n");
         display_usage (progname, subcommand);
         exit (1);
     }
 }
 
 //----------------------------------------------------------------------
 // main
 //----------------------------------------------------------------------
 int
 main_gdbserver (int argc, char *argv[])
 {
+    Error error;
+    MainLoop mainloop;
 #ifndef _WIN32
     // Setup signal handlers first thing.
     signal (SIGPIPE, signal_handler);
-    signal (SIGHUP, signal_handler);
+    MainLoop::SignalHandleUP sighup_handle = mainloop.RegisterSignal(SIGHUP, sighup_handler, error);
 #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;
-    Error error;
     int ch;
     std::string platform_name;
     std::string attach_target;
     std::string named_pipe_path;
     std::string log_file;
     StringRef log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
     int unnamed_pipe_fd = -1;
     bool reverse_connect = false;
#endif
     {
         display_usage(progname, subcommand);
         exit(255);
     }
 
     // Setup the platform that GDBRemoteCommunicationServerLLGS will use.
     lldb::PlatformSP platform_sp = setup_platform (platform_name);
 
-    GDBRemoteCommunicationServerLLGS gdb_server (platform_sp);
+    GDBRemoteCommunicationServerLLGS gdb_server (platform_sp, mainloop);
 
     const char *const host_and_port = argv[0];
     argc -= 1;
     argv += 1;
 
     // Any arguments left over are for the program that we need to launch. If there
     // are no arguments, then the GDB server will start up and wait for an 'A' packet
     // to launch a program, or a vAttach packet to attach to an existing process, unless
     // explicitly asked to attach with the --attach={pid|program_name} form.
     if (!attach_target.empty ())
         handle_attach (gdb_server, attach_target);
     else if (argc > 0)
         handle_launch (gdb_server, argc, argv);
 
     // Print version info.
     printf("%s-%s", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
 
-    ConnectToRemote(gdb_server, reverse_connect,
+    ConnectToRemote(mainloop, gdb_server, reverse_connect,
                     host_and_port, progname, subcommand,
                     named_pipe_path.c_str(), unnamed_pipe_fd);
 
     fprintf(stderr, "lldb-server exiting...\n");
 
     return 0;
 }

tools/lldb-server/lldb-platform.cpp

do {
             // connections while a connection is active.
             listening_socket_up.reset();
         }
         platform.SetConnection (new ConnectionFileDescriptor(socket));
 
         if (platform.IsConnected())
         {
             // After we connected, we need to get an initial ack from...
-            if (platform.HandshakeWithClient(&error))
+            if (platform.HandshakeWithClient())
             {
                 bool interrupt = false;
                 bool done = false;
                 while (!interrupt && !done)
                 {
                     if (platform.GetPacketAndSendResponse (UINT32_MAX, error, interrupt, done) != GDBRemoteCommunication::PacketResult::Success)
                         break;
                 }