Revert "Add Pipe::WriteWithTimeout method"

I have observed an increased flakyness in the buildbots. I suspect something was relying on the
fact that Pipe::Write had an implicit timeout of 1s, which this commit has removed. Reverting
while I investigate.

llvm-svn: 242767

6 files changed, 14 insertions, 56 deletions

diff --git a/lldb/include/lldb/Host/PipeBase.h b/lldb/include/lldb/Host/PipeBase.h
index 8b11d704175..8680a252d8b 100644
--- a/lldb/include/lldb/Host/PipeBase.h
+++ b/lldb/include/lldb/Host/PipeBase.h
@@ -49,13 +49,9 @@ class PipeBase
     // Delete named pipe.
     virtual Error Delete(llvm::StringRef name) = 0;
 
-    virtual Error WriteWithTimeout(const void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_written) = 0;
+    virtual Error Write(const void *buf, size_t size, size_t &bytes_written) = 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);
-    Error Write(const void *buf, size_t size, size_t &bytes_written);
-
-    static const std::chrono::microseconds kInfiniteTimeout;
 };
 }
 
diff --git a/lldb/include/lldb/Host/posix/PipePosix.h b/lldb/include/lldb/Host/posix/PipePosix.h
index 889da9310f2..710b77d34bd 100644
--- a/lldb/include/lldb/Host/posix/PipePosix.h
+++ b/lldb/include/lldb/Host/posix/PipePosix.h
@@ -74,7 +74,7 @@ public:
     Delete(llvm::StringRef name) override;
 
     Error
-    WriteWithTimeout(const void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_written) override;
+    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;
 
diff --git a/lldb/include/lldb/Host/windows/PipeWindows.h b/lldb/include/lldb/Host/windows/PipeWindows.h
index be8bf02756f..7170c7c3681 100644
--- a/lldb/include/lldb/Host/windows/PipeWindows.h
+++ b/lldb/include/lldb/Host/windows/PipeWindows.h
@@ -49,7 +49,7 @@ class PipeWindows : public PipeBase
 
     Error Delete(llvm::StringRef name) override;
 
-    Error WriteWithTimeout(const void *buf, size_t size, const std::chrono::microseconds &timeout, size_t &bytes_written) 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;
 
     // PipeWindows specific methods.  These allow access to the underlying OS handle.
diff --git a/lldb/source/Host/common/PipeBase.cpp b/lldb/source/Host/common/PipeBase.cpp
index 4b607a2bb63..a9d6e6f46c8 100644
--- a/lldb/source/Host/common/PipeBase.cpp
+++ b/lldb/source/Host/common/PipeBase.cpp
@@ -11,24 +11,17 @@
 
 using namespace lldb_private;
 
-const std::chrono::microseconds PipeBase::kInfiniteTimeout(-1);
 
 PipeBase::~PipeBase() = default;
 
 Error
 PipeBase::OpenAsWriter(llvm::StringRef name, bool child_process_inherit)
 {
-    return OpenAsWriterWithTimeout(name, child_process_inherit, kInfiniteTimeout);
+    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, kInfiniteTimeout, bytes_read);
-}
-
-Error
-PipeBase::Write(const void *buf, size_t size, size_t &bytes_written)
-{
-    return WriteWithTimeout(buf, size, kInfiniteTimeout, bytes_written);
+    return ReadWithTimeout(buf, size, std::chrono::microseconds::zero(), bytes_read);
 }
diff --git a/lldb/source/Host/posix/PipePosix.cpp b/lldb/source/Host/posix/PipePosix.cpp
index f1f4e667902..0ed319facf9 100644
--- a/lldb/source/Host/posix/PipePosix.cpp
+++ b/lldb/source/Host/posix/PipePosix.cpp
@@ -73,8 +73,7 @@ SelectIO(int handle, bool is_read, const std::function<Error(bool&)> &io_handler
     while (!done)
     {
         struct timeval tv = {0, 0};
-        struct timeval *tv_p = &tv;
-        if (timeout != PipeBase::kInfiniteTimeout)
+        if (timeout != microseconds::zero())
         {
             const auto remaining_dur = duration_cast<microseconds>(finish_time - Now());
             if (remaining_dur.count() <= 0)
@@ -89,7 +88,7 @@ SelectIO(int handle, bool is_read, const std::function<Error(bool&)> &io_handler
             tv.tv_usec = dur_usecs.count();
         }
         else
-            tv_p = nullptr;
+            tv.tv_sec = 1;
 
         FD_ZERO(&fds);
         FD_SET(handle, &fds);
@@ -97,7 +96,7 @@ SelectIO(int handle, bool is_read, const std::function<Error(bool&)> &io_handler
         const auto retval = ::select(handle + 1,
                                      (is_read) ? &fds : nullptr,
                                      (is_read) ? nullptr : &fds,
-                                     nullptr, tv_p);
+                                     nullptr, &tv);
         if (retval == -1)
         {
             if (errno == EINTR)
@@ -271,7 +270,7 @@ PipePosix::OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inhe
 
     while (!CanWrite())
     {
-        if (timeout != kInfiniteTimeout)
+        if (timeout != microseconds::zero())
         {
             const auto dur = duration_cast<microseconds>(finish_time - Now()).count();
             if (dur <= 0)
@@ -402,10 +401,7 @@ PipePosix::ReadWithTimeout(void *buf, size_t size, const std::chrono::microsecon
 }
 
 Error
-PipePosix::WriteWithTimeout(const void *buf,
-                            size_t size,
-                            const std::chrono::microseconds &timeout,
-                            size_t &bytes_written)
+PipePosix::Write(const void *buf, size_t size, size_t &bytes_written)
 {
     bytes_written = 0;
     if (!CanWrite())
@@ -431,5 +427,5 @@ PipePosix::WriteWithTimeout(const void *buf,
 
                         return error;
                     },
-                    timeout);
+                    std::chrono::microseconds::zero());
 }
diff --git a/lldb/source/Host/windows/PipeWindows.cpp b/lldb/source/Host/windows/PipeWindows.cpp
index e2029971742..d4afd6e7494 100644
--- a/lldb/source/Host/windows/PipeWindows.cpp
+++ b/lldb/source/Host/windows/PipeWindows.cpp
@@ -289,7 +289,7 @@ PipeWindows::ReadWithTimeout(void *buf, size_t size, const std::chrono::microsec
     if (!result && GetLastError() != ERROR_IO_PENDING)
         return Error(::GetLastError(), eErrorTypeWin32);
 
-    DWORD timeout = (duration == kInfiniteTimeout) ? INFINITE : duration.count() * 1000;
+    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)
     {
@@ -319,10 +319,7 @@ PipeWindows::ReadWithTimeout(void *buf, size_t size, const std::chrono::microsec
 }
 
 Error
-PipeWindows::WriteWithTimeout(const void *buf,
-                              size_t num_bytes,
-                              const std::chrono::microseconds &duration,
-                              size_t &bytes_written)
+PipeWindows::Write(const void *buf, size_t num_bytes, size_t &bytes_written)
 {
     if (!CanWrite())
         return Error(ERROR_INVALID_HANDLE, eErrorTypeWin32);
@@ -332,32 +329,8 @@ PipeWindows::WriteWithTimeout(const void *buf,
     if (!write_result && GetLastError() != ERROR_IO_PENDING)
         return Error(::GetLastError(), eErrorTypeWin32);
 
-    DWORD timeout = (duration == kInfiniteTimeout) ? INFINITE : duration.count() * 1000;
-    DWORD wait_result = ::WaitForSingleObject(m_write_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;
-        DWORD failure_error = ::GetLastError();
-        if (wait_result == WAIT_TIMEOUT)
-        {
-            BOOL cancel_result = CancelIoEx(m_read, &m_write_overlapped);
-            if (!cancel_result && GetLastError() == ERROR_NOT_FOUND)
-                failed = false;
-        }
-        if (failed)
-            return Error(failure_error, eErrorTypeWin32);
-    }
-
-    // Now we call GetOverlappedResult setting bWait to false, since we've already waited
-    // as long as we're willing to.
-    BOOL result = GetOverlappedResult(m_write, &m_write_overlapped, &sys_bytes_written, FALSE);
+    BOOL result = GetOverlappedResult(m_write, &m_write_overlapped, &sys_bytes_written, TRUE);
     if (!result)
         return Error(::GetLastError(), eErrorTypeWin32);
-
-    bytes_written = sys_bytes_written;
     return Error();
 }