Prevent ProcessGDBRemote from launching local debug server in case of remote debug server connection failure

[ovyalov]

Summary

If remote platform is used and we're losing remote debug server connection in between Process::ConnectRemote and Process::Attach (in context of PlatformRemoteGDBServer::Attach) current implementation of ProcessGDBRemote thinks that we're in local debug mode and tries to spawn a local debug server. This CL checks whether ProcessGDBRemote is using a remote platform and fails if remote debug server connection is lost.

[labath]

Nice catch. Looks good.

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

3516

I find this name somewhat misleading. Check would generally imply a read-only operation, but this actually establishes the connection in some circumstances. I'd go for EstablishConnectionIfNeeded or something like that.

[ovyalov]

Addressed review comments - renamed the method to EstablishConnectionIfNeeded.

[ovyalov]

Files:

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

Users:

ovyalov (Author)

http://reviews.llvm.org/rL253906

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

GetFlags () const
         return m_flags;
     }
 
     bool
     UpdateThreadList (ThreadList &old_thread_list, 
                       ThreadList &new_thread_list) override;
 
     Error
+    EstablishConnectionIfNeeded (const ProcessInfo &process_info);
+
+    Error
     LaunchAndConnectToDebugserver (const ProcessInfo &process_info);
 
     void
     KillDebugserverProcess ();
 
     void
     BuildDynamicRegisterInfo (bool force);
 

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

ProcessGDBRemote::DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
 
     //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
     //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
     //  ::LogSetLogFile ("/dev/stdout");
 
     ObjectFile * object_file = exe_module->GetObjectFile();
     if (object_file)
     {
-        // Make sure we aren't already connected?
-        if (!m_gdb_comm.IsConnected())
-        {
-            error = LaunchAndConnectToDebugserver (launch_info);
-        }
-        
+        error = EstablishConnectionIfNeeded (launch_info);
         if (error.Success())
         {
             lldb_utility::PseudoTerminal pty;
             const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
 
             PlatformSP platform_sp (GetTarget().GetPlatform());
             if (disable_stdio)
             {
ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info)
 
     if (log)
         log->Printf ("ProcessGDBRemote::%s()", __FUNCTION__);
 
     // Clear out and clean up from any current state
     Clear();
     if (attach_pid != LLDB_INVALID_PROCESS_ID)
     {
-        // Make sure we aren't already connected?
-        if (!m_gdb_comm.IsConnected())
-        {
-            error = LaunchAndConnectToDebugserver (attach_info);
-            
-            if (error.Fail())
-            {
-                const char *error_string = error.AsCString();
-                if (error_string == NULL)
-                    error_string = "unable to launch " DEBUGSERVER_BASENAME;
-
-                SetExitStatus (-1, error_string);
-            }
-        }
-    
+        error = EstablishConnectionIfNeeded (attach_info);
         if (error.Success())
         {
             m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
 
             char packet[64];
             const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, attach_pid);
             SetID (attach_pid);            
             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet, packet_len));
         }
+        else
+            SetExitStatus (-1, error.AsCString());
     }
 
     return error;
 }
 
 Error
 ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, const ProcessAttachInfo &attach_info)
 {
     Error error;
     // Clear out and clean up from any current state
     Clear();
 
     if (process_name && process_name[0])
     {
-        // Make sure we aren't already connected?
-        if (!m_gdb_comm.IsConnected())
-        {
-            error = LaunchAndConnectToDebugserver (attach_info);
-
-            if (error.Fail())
-            {
-                const char *error_string = error.AsCString();
-                if (error_string == NULL)
-                    error_string = "unable to launch " DEBUGSERVER_BASENAME;
-
-                SetExitStatus (-1, error_string);
-            }
-        }
-
+        error = EstablishConnectionIfNeeded (attach_info);
         if (error.Success())
         {
             StreamString packet;
             
             m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
             
             if (attach_info.GetWaitForLaunch())
             {
if (process_name && process_name[0])
             else
                 packet.PutCString("vAttachName");
             packet.PutChar(';');
             packet.PutBytesAsRawHex8(process_name, strlen(process_name), endian::InlHostByteOrder(), endian::InlHostByteOrder());
             
             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet.GetData(), packet.GetSize()));
 
         }
+        else
+            SetExitStatus (-1, error.AsCString());
     }
     return error;
 }
 
 void
 ProcessGDBRemote::DidExit ()
 {
     // When we exit, disconnect from the GDB server communications
if (log)
         log->Printf ("ProcessGDBRemote::DoSignal (signal = %d)", signo);
 
     if (!m_gdb_comm.SendAsyncSignal (signo))
         error.SetErrorStringWithFormat("failed to send signal %i", signo);
     return error;
 }
 
 Error
+ProcessGDBRemote::EstablishConnectionIfNeeded (const ProcessInfo &process_info)
+{
+    // Make sure we aren't already connected?
+    if (m_gdb_comm.IsConnected())
+        return Error();
+
+    PlatformSP platform_sp (GetTarget ().GetPlatform ());
+    if (platform_sp && !platform_sp->IsHost ())
+        return Error("Lost debug server connection");
+
+    auto error = LaunchAndConnectToDebugserver (process_info);
+    if (error.Fail())
+    {
+        const char *error_string = error.AsCString();
+        if (error_string == nullptr)
+            error_string = "unable to launch " DEBUGSERVER_BASENAME;
+    }
+    return error;
+}
+
+Error
 ProcessGDBRemote::LaunchAndConnectToDebugserver (const ProcessInfo &process_info)
 {
     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;