Use timeout when reading debugserver's port from a named pipe.

[ovyalov]

Summary

After debugserver is launched (either by lldb or lldb-platform) it may terminate prematurely even after successful start by various reasons:

1. Invalid flag configuration.
2. Socket errors.

...

In this case a named pipe (used to deliver a port that debugserver listens) will be never opened and written - so, lldb or platform hangs forever.
This CL fixes the problem by opening pipe in non-blocking mode and waiting on pipe data via select.

Potentially, this issue might be handled even more properly if GDBRemoteCommunication::StartDebugserverProcess gets notified about debugserver termination (via callback or condition variable). If such approach sounds reasonable I can do it as a next step.

[clayborg]

Looks good.

[Eugene.Zelenko]

Committed in r223251.

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

 //===-- GDBRemoteCommunication.cpp ------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "GDBRemoteCommunication.h"
 
 // C Includes
 #include <limits.h>
 #include <string.h>
+#include <sys/select.h>
 #include <sys/stat.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"

 # define DEBUGSERVER_BASENAME    "debugserver"
 #else
 # define DEBUGSERVER_BASENAME    "lldb-gdbserver"
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
+namespace
+{
+
+Error
+ReadPortFromPipe (const char *const named_pipe_path, uint16_t& port, const int timeout_secs)
+{
+    File name_pipe_file;
+    auto error = name_pipe_file.Open (named_pipe_path, File::eOpenOptionRead | File::eOpenOptionNonBlocking);
+    if (error.Fail ())
+        return error;
+
+    struct timeval tv = {timeout_secs, 0};
+    const auto pipe_handle = name_pipe_file.GetWaitableHandle ();
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(pipe_handle, &rfds);
+
+    const auto retval = ::select (pipe_handle + 1, &rfds, NULL, NULL, &tv);
+    if (retval == -1)
+    {
+        error.SetErrorToErrno ();
+        return error;
+    }
+    if (retval == 0)
+    {
+        error.SetErrorString ("timeout exceeded");
+        return error;
+    }
+
+    char port_cstr[256];
+    port_cstr[0] = '\0';
+    size_t num_bytes = sizeof(port_cstr);
+    error = name_pipe_file.Read (port_cstr, num_bytes);
+
+    if (error.Success ())
+    {
+        assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
+        port = Args::StringToUInt32 (port_cstr, 0);
+    }
+    return error;
+}
+
+}
+
 GDBRemoteCommunication::History::History (uint32_t size) :
     m_packets(),
     m_curr_idx (0),
     m_total_packet_count (0),
     m_dumped_to_log (false)
 {
     m_packets.resize(size);
 }
#endif
         launch_info.AppendCloseFileAction (STDIN_FILENO);
         launch_info.AppendCloseFileAction (STDOUT_FILENO);
         launch_info.AppendCloseFileAction (STDERR_FILENO);
 
         // Redirect STDIN, STDOUT and STDERR to "/dev/null".
         launch_info.AppendSuppressFileAction (STDIN_FILENO, true, false);
         launch_info.AppendSuppressFileAction (STDOUT_FILENO, false, true);
         launch_info.AppendSuppressFileAction (STDERR_FILENO, false, true);
-        
         error = Host::LaunchProcess(launch_info);
-        
         if (error.Success() && launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
         {
             if (named_pipe_path[0])
             {
-                File name_pipe_file;
-                error = name_pipe_file.Open(named_pipe_path, File::eOpenOptionRead);
+                error = ReadPortFromPipe(named_pipe_path, out_port, 10);
                 if (error.Success())
                 {
-                    char port_cstr[256];
-                    port_cstr[0] = '\0';
-                    size_t num_bytes = sizeof(port_cstr);
-                    error = name_pipe_file.Read(port_cstr, num_bytes);
-                    assert (error.Success());
-                    assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
-                    out_port = Args::StringToUInt32(port_cstr, 0);
-                    name_pipe_file.Close();
+                    if (log)
+                        log->Printf("GDBRemoteCommunication::%s() debugserver listens %u port", __FUNCTION__, out_port);
+                }
+                else
+                {
+                    if (log)
+                        log->Printf("GDBRemoteCommunication::%s() failed to read a port value from named pipe %s: %s", __FUNCTION__, named_pipe_path, error.AsCString());
                 }
                 FileSystem::Unlink(named_pipe_path);
             }
             else if (listen)
             {
                 
             }
             else