Extend PipePosix with support for named pipes/timeout-based IO and integrate it with GDBRemoteCommunication / lldb-gdbserver.

[ovyalov]

Summary

Make PipePosix to support next operations:

• Create a named pipe.
• Open reader and writer sides of a named pipe.
• Timeout-based Read and Write operations.
• Added Delete call to PipeBase interface since named pipe removal differs for POSIX and Windows pipes.

Integrated Pipe class into GDBRemoteCommunication::StartDebugserverProcess and lldb-gdbserver in order to support reading and writing a port value to a named pipe.

[clayborg]

We haven't been using std::chrono in any API yet, but it would be nice to convert over to using it more as fixes permit.

Looks fine.

[zturner]

source/Host/posix/PipePosix.cpp

186

Why did we change this from OpenAsReader to OpenAsReaderWithTimeout? The timeout is never used, for one thing, so it's buggy, and it's less flexible, since you can't specify the timeout on individual reads.

[ovyalov]

My initial intent was to make interface of OpenAsReader symmetrical to what we have for OpenAsWriter. But since timeout isn't used by OpenAsReaderWithTimeout I've removed this method.
Please take another look!

Thank you.

[zturner]

Looks good, I like this better. In the future if we need to write with timeout we can add a WriteWithTimeout(). But usually that's not a common operation since it's not often you have to serialize on writes, so I expect it won't be needed.

Feel free to submit after removing OpenAsWriterWithTimeout().

include/lldb/Host/PipeBase.h

32

This probably needs to go away now too.

[ovyalov]

Please see my comment.

include/lldb/Host/PipeBase.h

32

We need this method on POSIX systems since attempt to open a writer in non-blocking mode fails with ENXIO if corresponding reader side hasn't opened yet. So, timeout allows to wait for a reader to be opened.

[zturner]

include/lldb/Host/PipeBase.h

32

Couldn't we implement the timeout at a higher level then? It's confusing currently, because in ReadWithTimeout(), a timeout value of 0 means block indefinitely, and in OpenAsWriterWithTimeout(), it means just return an error.

Maybe OpenAsWriter() can simply return an error and you can implement the retry at a higher level? It could return an error from the generic category indicating that the reader hasn't opened yet, and then Windows can do the same, so that the retry logic could be written at a higher level.

Reading and writing are a little different in that with a Read, the most common use case is to block until its finished, and you very rarely want to return immediately and do something else if there's no data. So it makes sense for ReadWithTimeout() to use 0 == INFINITE, but then OpenForWriteWithTiemout() becomes confusing.

Thoguhts?

[ovyalov]

include/lldb/Host/PipeBase.h

32

I believe both ReadWithTimeout and OpenAsWriterWithTimeout follow the same pattern - if timeout == zero() a operation blocks until it either succeeds or fails.
OpenAsWriterWithTimeout with zero timeout retries infinitely (sleeping 0.1 sec between retries) until writer successfully opened or a permanent error encountered (i.e. any error != ENXIO) - e.g. invalid pipe name.

[zturner]

Ahh, you're right, misread the code. No complaints then.

[Eugene.Zelenko]

Committed in r225849.

include/lldb/Host/PipeBase.h

 #include "lldb/Core/Error.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace lldb_private
 {
 class PipeBase
 {
   public:
-    virtual ~PipeBase() {}
+    virtual ~PipeBase();
 
     virtual Error CreateNew(bool child_process_inherit) = 0;
     virtual Error CreateNew(llvm::StringRef name, bool child_process_inherit) = 0;
+
     virtual Error OpenAsReader(llvm::StringRef name, bool child_process_inherit) = 0;
-    virtual Error OpenAsWriter(llvm::StringRef name, bool child_process_inherit) = 0;
+
+    Error OpenAsWriter(llvm::StringRef name, bool child_process_inherit);
+    virtual Error OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout) = 0;
 
     virtual bool CanRead() const = 0;
     virtual bool CanWrite() const = 0;
 
     virtual int GetReadFileDescriptor() const = 0;
     virtual int GetWriteFileDescriptor() const = 0;
     virtual int ReleaseReadFileDescriptor() = 0;
     virtual int ReleaseWriteFileDescriptor() = 0;
 
     // Close both descriptors
     virtual void Close() = 0;
 
+    // Delete named pipe.
+    virtual Error Delete(llvm::StringRef name) = 0;
+
     virtual Error Write(const void *buf, size_t size, size_t &bytes_written) = 0;
-    virtual Error Read(void *buf, size_t size, size_t &bytes_read) = 0;
-    virtual Error ReadWithTimeout(void *buf, size_t size, const std::chrono::milliseconds &timeout, size_t &bytes_read) = 0;
+    virtual Error ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_read) = 0;
+    Error Read(void *buf, size_t size, size_t &bytes_read);
 };
 }
 
 #endif

include/lldb/Host/posix/PipePosix.h

 {
 public:
     static int kInvalidDescriptor;
 
     PipePosix();
 
     ~PipePosix() override;
 
-    Error CreateNew(bool child_process_inherit) override;
-    Error CreateNew(llvm::StringRef name, bool child_process_inherit) override;
-    Error OpenAsReader(llvm::StringRef name, bool child_process_inherit) override;
-    Error OpenAsWriter(llvm::StringRef name, bool child_process_inherit) override;
-
-    bool CanRead() const override;
-    bool CanWrite() const override;
-
-    int GetReadFileDescriptor() const override;
-    int GetWriteFileDescriptor() const override;
-    int ReleaseReadFileDescriptor() override;
-    int ReleaseWriteFileDescriptor() override;
+    Error
+    CreateNew(bool child_process_inherit) override;
+    Error
+    CreateNew(llvm::StringRef name, bool child_process_inherit) override;
+    Error
+    OpenAsReader(llvm::StringRef name, bool child_process_inherit) override;
+    Error
+    OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout) override;
+
+    bool
+    CanRead() const override;
+    bool
+    CanWrite() const override;
+
+    int
+    GetReadFileDescriptor() const override;
+    int
+    GetWriteFileDescriptor() const override;
+    int
+    ReleaseReadFileDescriptor() override;
+    int
+    ReleaseWriteFileDescriptor() override;
 
     // Close both descriptors
-    void Close() override;
+    void
+    Close() override;
 
-    Error Write(const void *buf, size_t size, size_t &bytes_written) override;
-    Error Read(void *buf, size_t size, size_t &bytes_read) override;
-    Error ReadWithTimeout(void *buf, size_t size, const std::chrono::milliseconds &timeout, size_t &bytes_read) override;
+    Error
+    Delete(llvm::StringRef name) override;
+
+    Error
+    Write(const void *buf, size_t size, size_t &bytes_written) override;
+    Error
+    ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_read) override;
 
 private:
-  void CloseReadFileDescriptor();
-  void CloseWriteFileDescriptor();
+    void
+    CloseReadFileDescriptor();
+    void
+    CloseWriteFileDescriptor();
 
     int m_fds[2];
 };
 
 } // namespace lldb_private
 
 #endif  // #if defined(__cplusplus)
 #endif  // liblldb_Host_posix_PipePosix_h_

include/lldb/Host/windows/PipeWindows.h

 {
   public:
     PipeWindows();
     ~PipeWindows() override;
 
     Error CreateNew(bool child_process_inherit) override;
     Error CreateNew(llvm::StringRef name, bool child_process_inherit) override;
     Error OpenAsReader(llvm::StringRef name, bool child_process_inherit) override;
-    Error OpenAsWriter(llvm::StringRef name, bool child_process_inherit) override;
+    Error OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout) override;
 
     bool CanRead() const override;
     bool CanWrite() const override;
 
     int GetReadFileDescriptor() const override;
     int GetWriteFileDescriptor() const override;
     int ReleaseReadFileDescriptor() override;
     int ReleaseWriteFileDescriptor() override;
 
     void Close() override;
 
+    Error Delete(llvm::StringRef name) override;
+
     Error Write(const void *buf, size_t size, size_t &bytes_written) override;
-    Error Read(void *buf, size_t size, size_t &bytes_read) override;
-    Error ReadWithTimeout(void *buf, size_t size, const std::chrono::milliseconds &timeout, size_t &bytes_read) override;
+    Error ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_read) override;
 
     // PipeWindows specific methods.  These allow access to the underlying OS handle.
     HANDLE GetReadNativeHandle();
     HANDLE GetWriteNativeHandle();
 
   private:
     Error OpenNamedPipe(llvm::StringRef name, bool child_process_inherit, bool is_read);
 

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     2377C2F819E613C100737875 /* PipePosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2377C2F719E613C100737875 /* PipePosix.cpp */; };
     23CDD8FB19D47B3600461DDC /* ThreadStateCoordinator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23CDD8E819D3E13200461DDC /* ThreadStateCoordinator.cpp */; };
     23DDF226196C3EE600BB8417 /* CommandOptionValidators.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DDF224196C3EE600BB8417 /* CommandOptionValidators.cpp */; };
     23EDE33319269E7C00F6A132 /* NativeRegisterContext.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23EDE3301926839700F6A132 /* NativeRegisterContext.cpp */; };
     23EFE389193D1ABC00E54E54 /* SBTypeEnumMember.h in Headers */ = {isa = PBXBuildFile; fileRef = 23EFE388193D1ABC00E54E54 /* SBTypeEnumMember.h */; settings = {ATTRIBUTES = (Public, ); }; };
     23EFE38B193D1AEC00E54E54 /* SBTypeEnumMember.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23EFE38A193D1AEC00E54E54 /* SBTypeEnumMember.cpp */; };
     23F4034D1926E0F60046DC9B /* NativeRegisterContextRegisterInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */; };
     25420ECD1A6490B8009ADBCB /* OptionValueChar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ECC1A6490B8009ADBCB /* OptionValueChar.cpp */; };
+    25420ED21A649D88009ADBCB /* PipeBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 25420ED11A649D88009ADBCB /* PipeBase.cpp */; };
     260157C61885F51C00F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     260157C71885F52500F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     260157C81885F53100F875CF /* libpanel.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 260157C41885F4FF00F875CF /* libpanel.dylib */; };
     2606EDDE184E68940034641B /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 260C876910F538E700BB2B04 /* Foundation.framework */; };
     2606EDDF184E68A10034641B /* liblldb-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2689FFCA13353D7A00698AC0 /* liblldb-core.a */; };
     260A248E15D06C50009981B0 /* OptionValues.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A248D15D06C4F009981B0 /* OptionValues.h */; };
     260A39A619647A3A004B4130 /* Pipe.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A39A519647A3A004B4130 /* Pipe.h */; };
     260A63171861008E00FECF8E /* IOHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 260A63161861008E00FECF8E /* IOHandler.h */; };
/* Begin PBXFileReference section */
     23EDE3311926843600F6A132 /* NativeRegisterContext.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NativeRegisterContext.h; path = include/lldb/Target/NativeRegisterContext.h; sourceTree = "<group>"; };
     23EDE3371926AAD500F6A132 /* RegisterInfoInterface.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RegisterInfoInterface.h; path = Utility/RegisterInfoInterface.h; sourceTree = "<group>"; };
     23EFE388193D1ABC00E54E54 /* SBTypeEnumMember.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBTypeEnumMember.h; path = include/lldb/API/SBTypeEnumMember.h; sourceTree = "<group>"; };
     23EFE38A193D1AEC00E54E54 /* SBTypeEnumMember.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = SBTypeEnumMember.cpp; path = source/API/SBTypeEnumMember.cpp; sourceTree = "<group>"; };
     23F403471926C8D50046DC9B /* NativeRegisterContextRegisterInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NativeRegisterContextRegisterInfo.h; path = include/lldb/Target/NativeRegisterContextRegisterInfo.h; sourceTree = "<group>"; };
     23F403481926CC250046DC9B /* NativeRegisterContextRegisterInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NativeRegisterContextRegisterInfo.cpp; path = source/Target/NativeRegisterContextRegisterInfo.cpp; sourceTree = "<group>"; };
     25420ECC1A6490B8009ADBCB /* OptionValueChar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = OptionValueChar.cpp; path = source/Interpreter/OptionValueChar.cpp; sourceTree = "<group>"; };
     25420ECE1A64911B009ADBCB /* OptionValueChar.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = OptionValueChar.h; path = include/lldb/Interpreter/OptionValueChar.h; sourceTree = "<group>"; };
+    25420ED11A649D88009ADBCB /* PipeBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PipeBase.cpp; sourceTree = "<group>"; };
     260157C41885F4FF00F875CF /* libpanel.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libpanel.dylib; path = /usr/lib/libpanel.dylib; sourceTree = "<absolute>"; };
     260223E7115F06D500A601A2 /* SBCommunication.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBCommunication.h; path = include/lldb/API/SBCommunication.h; sourceTree = "<group>"; };
     260223E8115F06E500A601A2 /* SBCommunication.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBCommunication.cpp; path = source/API/SBCommunication.cpp; sourceTree = "<group>"; };
     26022531115F27FA00A601A2 /* SBFileSpec.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SBFileSpec.h; path = include/lldb/API/SBFileSpec.h; sourceTree = "<group>"; };
     26022532115F281400A601A2 /* SBFileSpec.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBFileSpec.cpp; path = source/API/SBFileSpec.cpp; sourceTree = "<group>"; };
     260A248D15D06C4F009981B0 /* OptionValues.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OptionValues.h; path = include/lldb/Interpreter/OptionValues.h; sourceTree = "<group>"; };
     260A39A519647A3A004B4130 /* Pipe.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = Pipe.h; path = include/lldb/Host/Pipe.h; sourceTree = "<group>"; };
     260A63111860FDB600FECF8E /* Queue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Queue.h; path = include/lldb/Target/Queue.h; sourceTree = "<group>"; };
4CEE62F71145F1C70064CF93 /* GDB Remote */ = {
       );
       name = "GDB Remote";
       path = "gdb-remote";
       sourceTree = "<group>";
     };
     69A01E1A1236C5D400C660B5 /* common */ = {
       isa = PBXGroup;
       children = (
+        25420ED11A649D88009ADBCB /* PipeBase.cpp */,
         26CFDCA2186163A4000E63E5 /* Editline.cpp */,
         260C6EA213011581005E16B0 /* File.cpp */,
         26FA43171301048600E71120 /* FileSpec.cpp */,
         69A01E1B1236C5D400C660B5 /* Condition.cpp */,
         69A01E1C1236C5D400C660B5 /* Host.cpp */,
         3FDFE53419A29327009756A7 /* HostInfoBase.cpp */,
         3FDFED2419BA6D96009756A7 /* HostNativeThreadBase.cpp */,
         3FDFED2C19C257A0009756A7 /* HostProcess.cpp */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         2689006D13353E0E00698AC0 /* IRExecutionUnit.cpp in Sources */,
         2689006E13353E1A00698AC0 /* File.cpp in Sources */,
         94D6A0AB16CEB55F00833B6E /* NSDictionary.cpp in Sources */,
         2689006F13353E1A00698AC0 /* FileSpec.cpp in Sources */,
         2689007013353E1A00698AC0 /* Condition.cpp in Sources */,
         2689007113353E1A00698AC0 /* Host.cpp in Sources */,
         2635879417822FC2004C30BA /* SymbolVendorELF.cpp in Sources */,
         2689007213353E1A00698AC0 /* Mutex.cpp in Sources */,
+        25420ED21A649D88009ADBCB /* PipeBase.cpp in Sources */,
         2689007313353E1A00698AC0 /* Symbols.cpp in Sources */,
         26474CBC18D0CB2D0073DEBA /* RegisterContextMach_arm.cpp in Sources */,
         2689007413353E1A00698AC0 /* Terminal.cpp in Sources */,
         2689007513353E1A00698AC0 /* TimeValue.cpp in Sources */,
         2689007613353E1A00698AC0 /* CFCBundle.cpp in Sources */,
         94BA8B70176F97CE005A91B5 /* CommandHistory.cpp in Sources */,
         2689007713353E1A00698AC0 /* CFCData.cpp in Sources */,
         2689007813353E1A00698AC0 /* CFCMutableArray.cpp in Sources */,

source/Host/CMakeLists.txt

add_host_subdirectory(common
   common/IOObject.cpp
   common/Mutex.cpp
   common/MonitoringProcessLauncher.cpp
   common/NativeBreakpoint.cpp
   common/NativeBreakpointList.cpp
   common/NativeProcessProtocol.cpp
   common/NativeThreadProtocol.cpp
   common/OptionParser.cpp
+  common/PipeBase.cpp
   common/ProcessRunLock.cpp
   common/Socket.cpp
   common/SocketAddress.cpp
   common/SoftwareBreakpoint.cpp
   common/Symbols.cpp
   common/Terminal.cpp
   common/ThisThread.cpp
   common/ThreadLauncher.cpp

source/Host/common/PipeBase.cpp

+//===-- source/Host/common/PipeBase.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/PipeBase.h"
+
+using namespace lldb_private;
+
+
+PipeBase::~PipeBase() = default;
+
+Error
+PipeBase::OpenAsWriter(llvm::StringRef name, bool child_process_inherit)
+{
+    return OpenAsWriterWithTimeout(name, child_process_inherit, std::chrono::microseconds::zero());
+}
+
+Error
+PipeBase::Read(void *buf, size_t size, size_t &bytes_read)
+{
+    return ReadWithTimeout(buf, size, std::chrono::microseconds::zero(), bytes_read);
+}

source/Host/posix/PipePosix.cpp

 //===-- PipePosix.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/PipePosix.h"
+#include "lldb/Host/FileSystem.h"
+
+#include <functional>
+#include <thread>
 
 #include <errno.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
+#include <sys/stat.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 int PipePosix::kInvalidDescriptor = -1;
 
 enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 
 // pipe2 is supported by Linux, FreeBSD v10 and higher.
 // TODO: Add more platforms that support pipe2.
 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD__ >= 10)
 #define PIPE2_SUPPORTED 1
 #else
 #define PIPE2_SUPPORTED 0
 #endif
 
 namespace
 {
 
+constexpr auto OPEN_WRITER_SLEEP_TIMEOUT_MSECS = 100;
+
 #if defined(FD_CLOEXEC) && !PIPE2_SUPPORTED
 bool SetCloexecFlag(int fd)
 {
     int flags = ::fcntl(fd, F_GETFD);
     if (flags == -1)
         return false;
     return (::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == 0);
 }
 #endif
 
+std::chrono::time_point<std::chrono::steady_clock>
+Now()
+{
+    return std::chrono::steady_clock::now();
+}
+
+Error
+SelectIO(int handle, bool is_read, const std::function<Error(bool&)> &io_handler, const std::chrono::microseconds &timeout)
+{
+    Error error;
+    fd_set fds;
+    bool done = false;
+
+    using namespace std::chrono;
+
+    const auto finish_time = Now() + timeout;
+
+    while (!done)
+    {
+        struct timeval tv = {0, 0};
+        if (timeout != microseconds::zero())
+        {
+            const auto remaining_dur = duration_cast<microseconds>(finish_time - Now());
+            if (remaining_dur.count() <= 0)
+            {
+                error.SetErrorString("timeout exceeded");
+                break;
+            }
+            const auto dur_secs = duration_cast<seconds>(remaining_dur);
+            const auto dur_usecs = remaining_dur % seconds(1);
+
+            tv.tv_sec = dur_secs.count();
+            tv.tv_usec = dur_usecs.count();
+        }
+        else
+            tv.tv_sec = 1;
+
+        FD_ZERO(&fds);
+        FD_SET(handle, &fds);
+
+        const auto retval = ::select(handle + 1,
+                                     (is_read) ? &fds : nullptr,
+                                     (is_read) ? nullptr : &fds,
+                                     nullptr, &tv);
+        if (retval == -1)
+        {
+            if (errno == EINTR)
+                continue;
+            error.SetErrorToErrno();
+            break;
+        }
+        if (retval == 0)
+        {
+            error.SetErrorString("timeout exceeded");
+            break;
+        }
+        if (!FD_ISSET(handle, &fds))
+        {
+            error.SetErrorString("invalid state");
+            break;
+        }
+
+        error = io_handler(done);
+        if (error.Fail())
+        {
+          if (error.GetError() == EINTR)
+              continue;
+            break;
+        }
+    }
+    return error;
+}
+
 }
 
 PipePosix::PipePosix()
 {
     m_fds[READ] = PipePosix::kInvalidDescriptor;
     m_fds[WRITE] = PipePosix::kInvalidDescriptor;
 }
 
 PipePosix::~PipePosix()
 {
     Close();
 }
 
 Error
 PipePosix::CreateNew(bool child_processes_inherit)
 {
-    Error error;
     if (CanRead() || CanWrite())
-    {
-        error.SetError(EINVAL, eErrorTypePOSIX);
-        return error;
-    }
+        return Error(EINVAL, eErrorTypePOSIX);
 
+    Error error;
 #if PIPE2_SUPPORTED
     if (::pipe2(m_fds, (child_processes_inherit) ? 0 : O_CLOEXEC) == 0)
         return error;
 #else
     if (::pipe(m_fds) == 0)
     {
 #ifdef FD_CLOEXEC
         if (!child_processes_inherit)
         {
             if (!SetCloexecFlag(m_fds[0]) || !SetCloexecFlag(m_fds[1]))
             {
                 error.SetErrorToErrno();
                 Close();
                 return error;
             }
         }
 #endif
         return error;
     }
 #endif
 
+    error.SetErrorToErrno();
     m_fds[READ] = PipePosix::kInvalidDescriptor;
     m_fds[WRITE] = PipePosix::kInvalidDescriptor;
-    error.SetErrorToErrno();
     return error;
 }
 
 Error
 PipePosix::CreateNew(llvm::StringRef name, bool child_process_inherit)
 {
-    Error error;
     if (CanRead() || CanWrite())
-        error.SetErrorString("Pipe is already opened");
-    else if (name.empty())
-        error.SetErrorString("Cannot create named pipe with empty name.");
-    else
-        error.SetErrorString("Not implemented");
+        return Error("Pipe is already opened");
+
+    Error error;
+    if (::mkfifo(name.data(), 0660) != 0)
+        error.SetErrorToErrno();
+
     return error;
 }
 
 Error
 PipePosix::OpenAsReader(llvm::StringRef name, bool child_process_inherit)
 {
-    Error error;
     if (CanRead() || CanWrite())
-        error.SetErrorString("Pipe is already opened");
-    else if (name.empty())
-        error.SetErrorString("Cannot open named pipe with empty name.");
+        return Error("Pipe is already opened");
+
+    int flags = O_RDONLY | O_NONBLOCK;
+    if (!child_process_inherit)
+        flags |= O_CLOEXEC;
+
+    Error error;
+    int fd = ::open(name.data(), flags);
+    if (fd != -1)
+        m_fds[READ] = fd;
     else
-        error.SetErrorString("Not implemented");
+        error.SetErrorToErrno();
+
     return error;
 }
 
 Error
-PipePosix::OpenAsWriter(llvm::StringRef name, bool child_process_inherit)
+PipePosix::OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout)
 {
-    Error error;
     if (CanRead() || CanWrite())
-        error.SetErrorString("Pipe is already opened");
-    else if (name.empty())
-        error.SetErrorString("Cannot create named pipe with empty name.");
+        return Error("Pipe is already opened");
+
+    int flags = O_WRONLY | O_NONBLOCK;
+    if (!child_process_inherit)
+        flags |= O_CLOEXEC;
+
+    using namespace std::chrono;
+    const auto finish_time = Now() + timeout;
+
+    while (!CanWrite())
+    {
+        if (timeout != microseconds::zero())
+        {
+            const auto dur = duration_cast<microseconds>(finish_time - Now()).count();
+            if (dur <= 0)
+                return Error("timeout exceeded - reader hasn't opened so far");
+        }
+
+        errno = 0;
+        int fd = ::open(name.data(), flags);
+        if (fd == -1)
+        {
+            const auto errno_copy = errno;
+            // We may get ENXIO if a reader side of the pipe hasn't opened yet.
+            if (errno_copy != ENXIO)
+                return Error(errno_copy, eErrorTypePOSIX);
+
+            std::this_thread::sleep_for(milliseconds(OPEN_WRITER_SLEEP_TIMEOUT_MSECS));
+        }
         else
-        error.SetErrorString("Not implemented");
-    return error;
+        {
+            m_fds[WRITE] = fd;
+        }
+    }
+
+    return Error();
 }
 
 int
 PipePosix::GetReadFileDescriptor() const
 {
     return m_fds[READ];
 }
 

 
 void
 PipePosix::Close()
 {
     CloseReadFileDescriptor();
     CloseWriteFileDescriptor();
 }
 
+Error
+PipePosix::Delete(llvm::StringRef name)
+{
+    return FileSystem::Unlink(name.data());
+}
+
 bool
 PipePosix::CanRead() const
 {
     return m_fds[READ] != PipePosix::kInvalidDescriptor;
 }
 
 bool
 PipePosix::CanWrite() const
 {
     return m_fds[WRITE] != PipePosix::kInvalidDescriptor;
 }
 
 void
 PipePosix::CloseReadFileDescriptor()
 {
     if (CanRead())
     {
-        int err;
-        err = close(m_fds[READ]);
+        close(m_fds[READ]);
         m_fds[READ] = PipePosix::kInvalidDescriptor;
     }
 }
 
 void
 PipePosix::CloseWriteFileDescriptor()
 {
     if (CanWrite())
     {
-        int err;
-        err = close(m_fds[WRITE]);
+        close(m_fds[WRITE]);
         m_fds[WRITE] = PipePosix::kInvalidDescriptor;
     }
 }
 
 Error
-PipePosix::Read(void *buf, size_t num_bytes, size_t &bytes_read)
+PipePosix::ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_read)
 {
     bytes_read = 0;
-    Error error;
+    if (!CanRead())
+        return Error(EINVAL, eErrorTypePOSIX);
 
-    if (CanRead())
+    auto handle = GetReadFileDescriptor();
+    return SelectIO(handle,
+                    true,
+                    [=, &bytes_read](bool &done)
                     {
-        const int fd = GetReadFileDescriptor();
-        int result = read(fd, buf, num_bytes);
-        if (result >= 0)
-            bytes_read = result;
-        else
-            error.SetErrorToErrno();
+                      Error error;
+                      auto result = ::read(handle,
+                                           reinterpret_cast<char*>(buf) + bytes_read,
+                                           size - bytes_read);
+                      if (result != -1)
+                      {
+                          bytes_read += result;
+                          if (bytes_read == size || result == 0)
+                              done = true;
                       }
                       else
-        error.SetError(EINVAL, eErrorTypePOSIX);
-
-    return error;
-}
+                          error.SetErrorToErrno();
 
-Error
-PipePosix::ReadWithTimeout(void *buf, size_t num_bytes, const std::chrono::milliseconds &duration, size_t &bytes_read)
-{
-    bytes_read = 0;
-    Error error;
-    error.SetErrorString("Not implemented");
                       return error;
+                  },
+                  timeout);
 }
 
 Error
-PipePosix::Write(const void *buf, size_t num_bytes, size_t &bytes_written)
+PipePosix::Write(const void *buf, size_t size, size_t &bytes_written)
 {
     bytes_written = 0;
-    Error error;
+    if (!CanWrite())
+        return Error(EINVAL, eErrorTypePOSIX);
 
-    if (CanWrite())
+    auto handle = GetWriteFileDescriptor();
+    return SelectIO(handle,
+                    false,
+                    [=, &bytes_written](bool &done)
                     {
-        const int fd = GetWriteFileDescriptor();
-        int result = write(fd, buf, num_bytes);
-        if (result >= 0)
-            bytes_written = result;
-        else
-            error.SetErrorToErrno();
+                        Error error;
+                        auto result = ::write(handle,
+                                              reinterpret_cast<const char*>(buf) + bytes_written,
+                                              size - bytes_written);
+                        if (result != -1)
+                        {
+                            bytes_written += result;
+                            if (bytes_written == size)
+                                done = true;
                         }
                         else
-        error.SetError(EINVAL, eErrorTypePOSIX);
+                            error.SetErrorToErrno();
 
                         return error;
+                    },
+                    std::chrono::microseconds::zero());
 }

source/Host/windows/PipeWindows.cpp

 {
     if (CanRead() || CanWrite())
         return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
 
     return OpenNamedPipe(name, child_process_inherit, true);
 }
 
 Error
-PipeWindows::OpenAsWriter(llvm::StringRef name, bool child_process_inherit)
+PipeWindows::OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit, const std::chrono::microseconds &timeout)
 {
     if (CanRead() || CanWrite())
         return Error(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
 
     return OpenNamedPipe(name, child_process_inherit, false);
 }
 
 Error

 
 void
 PipeWindows::Close()
 {
     CloseReadEndpoint();
     CloseWriteEndpoint();
 }
 
+Error
+PipeWindows::Delete(llvm::StringRef name)
+{
+    return Error();
+}
+
 bool
 PipeWindows::CanRead() const
 {
     return (m_read != INVALID_HANDLE_VALUE);
 }
 
 bool
 PipeWindows::CanWrite() const

 
 HANDLE
 PipeWindows::GetWriteNativeHandle()
 {
     return m_write;
 }
 
 Error
-PipeWindows::Read(void *buf, size_t size, size_t &bytes_read)
-{
-    return ReadWithTimeout(buf, size, std::chrono::milliseconds::zero(), bytes_read);
-}
-
-Error
-PipeWindows::ReadWithTimeout(void *buf, size_t size, const std::chrono::milliseconds &duration, size_t &bytes_read)
+PipeWindows::ReadWithTimeout(void *buf, size_t size, const std::chrono::microseconds &duration, size_t &bytes_read)
 {
     if (!CanRead())
         return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
 
     bytes_read = 0;
     DWORD sys_bytes_read = size;
     BOOL result = ::ReadFile(m_read, buf, sys_bytes_read, &sys_bytes_read, &m_read_overlapped);
     if (!result && GetLastError() != ERROR_IO_PENDING)
         return Error(::GetLastError(), eErrorTypeWin32);
 
-    DWORD timeout = (duration == std::chrono::milliseconds::zero()) ? INFINITE : duration.count();
+    DWORD timeout = (duration == std::chrono::microseconds::zero()) ? INFINITE : duration.count() * 1000;
     DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout);
     if (wait_result != WAIT_OBJECT_0)
     {
         // The operation probably failed.  However, if it timed out, we need to cancel the I/O.
         // Between the time we returned from WaitForSingleObject and the time we call CancelIoEx,
         // the operation may complete.  If that hapens, CancelIoEx will fail and return ERROR_NOT_FOUND.
         // If that happens, the original operation should be considered to have been successful.
         bool failed = true;

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

 
 // 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"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 
if (debugserver_exists)
         // use native registers, not the GDB registers
         debugserver_args.AppendArgument("--native-regs");   
         // make debugserver run in its own session so signals generated by 
         // special terminal key sequences (^C) don't affect debugserver
         debugserver_args.AppendArgument("--setsid");
 
         char named_pipe_path[PATH_MAX];
         named_pipe_path[0] = '\0';
+        Pipe port_named_pipe;
 
         bool listen = false;
         if (host_and_port[0])
         {
             // Create a temporary file to get the stdout/stderr and redirect the
             // output of the command into this file. We will later read this file
             // if all goes well and fill the data into "command_output_ptr"
 
if (debugserver_exists)
                 }
                 else
                 {
                     strncpy(named_pipe_path, "/tmp/debugserver-named-pipe.XXXXXX", sizeof(named_pipe_path));
                 }
 
                 if (::mktemp (named_pipe_path))
                 {
-#if defined(_WIN32)
-                    if ( false )
-#else
-                    if (::mkfifo(named_pipe_path, 0600) == 0)
-#endif
-                    {
-                        debugserver_args.AppendArgument("--named-pipe");
-                        debugserver_args.AppendArgument(named_pipe_path);
-                    }
-                }
-            }
+                    error = port_named_pipe.CreateNew(named_pipe_path, false);
+                    if (error.Fail())
+                        return error;
             else
             {
                 listen = true;
             }
         }
         else
         {
             // No host and port given, so lets listen on our end and make the debugserver
if (debugserver_exists)
         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 = port_named_pipe.OpenAsReader(named_pipe_path, false);
                 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());
+                    // Read port from pipe with 10 second timeout.
+                    error = port_named_pipe.ReadWithTimeout(port_cstr, num_bytes, std::chrono::microseconds(10 * 1000000), num_bytes);
+                    if (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());
+
+                    }
+                    port_named_pipe.Close();
+                }
+                else
+                {
+                    if (log)
+                        log->Printf("GDBRemoteCommunication::%s() failed to open named pipe %s for reading: %s", __FUNCTION__, named_pipe_path, error.AsCString());
+                }
+                const auto err = port_named_pipe.Delete(named_pipe_path);
+                if (err.Fail())
+                {
+                    if (log)
+                        log->Printf ("GDBRemoteCommunication::%s failed to delete pipe %s: %s", __FUNCTION__, named_pipe_path, err.AsCString());
                 }
-                FileSystem::Unlink(named_pipe_path);
             }
             else if (listen)
             {
                 
             }
             else
             {
                 // Make sure we actually connect with the debugserver...

tools/lldb-gdbserver/lldb-gdbserver.cpp

 #include "lldb/lldb-private-log.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/ConnectionMachPort.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Host/Pipe.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemoteLog.h"
 
JoinListenThread ()
     if (s_listen_thread.IsJoinable())
         s_listen_thread.Join(nullptr);
     return true;
 }
 
 Error
 writePortToPipe (const char *const named_pipe_path, const uint16_t port)
 {
-    Error error;
-
-    // FIXME use new generic named pipe support.
-    int fd = ::open (named_pipe_path, O_WRONLY);
-    if (fd == -1)
-    {
-        error.SetErrorToErrno ();
+    Pipe port_name_pipe;
+    // Wait for 10 seconds for pipe to be opened.
+    auto error = port_name_pipe.OpenAsWriterWithTimeout (named_pipe_path, false, std::chrono::microseconds (10 * 1000000));
+    if (error.Fail ())
         return error;
-    }
 
     char port_str[64];
-    const ssize_t port_str_len = ::snprintf (port_str, sizeof(port_str), "%u", port);
-    // Write the port number as a C string with the NULL terminator.
-    if (::write (fd, port_str, port_str_len + 1) == -1)
-        error.SetErrorToErrno ();
+    const auto port_str_len = ::snprintf (port_str, sizeof (port_str), "%u", port);
 
-    close (fd);
-    return error;
+    size_t bytes_written = 0;
+    // Write the port number as a C string with the NULL terminator.
+    return port_name_pipe.Write (port_str, port_str_len + 1, bytes_written);
 }
 
 void
 ConnectToRemote (GDBRemoteCommunicationServer &gdb_server, bool reverse_connect, const char *const host_and_port, const char *const progname, const char *const named_pipe_path)
 {
     Error error;
 
     if (host_and_port && host_and_port[0])