[lldb] Adding file and pipe support to lldb_private::MainLoopWindows.

This updates MainLoopWindows to support events for reading from a file and a socket type.

This unifies both handle types using WaitForMultipleEvents which can listen to both sockets and files for change events.

This should allow us to unify how we handle watching files/pipes/sockets on Windows and Posix systems.

Author: ashgti

lldb/include/lldb/Host/File.h

@@ -127,6 +127,7 @@ class File : public IOObject {
   /// \return
   ///     a valid handle or IOObject::kInvalidHandleValue
   WaitableHandle GetWaitableHandle() override;
+  bool HasReadableData() override;
 
   /// Get the file specification for this file, if possible.
   ///
@@ -400,6 +401,7 @@ class NativeFile : public File {
   Status Write(const void *buf, size_t &num_bytes) override;
   Status Close() override;
   WaitableHandle GetWaitableHandle() override;
+  bool HasReadableData() override;
   Status GetFileSpec(FileSpec &file_spec) const override;
   int GetDescriptor() const override;
   FILE *GetStream() override;

lldb/include/lldb/Host/Socket.h

@@ -158,6 +158,7 @@ class Socket : public IOObject {
 
   bool IsValid() const override { return m_socket != kInvalidSocketValue; }
   WaitableHandle GetWaitableHandle() override;
+  bool HasReadableData() override;
 
   static llvm::Expected<HostAndPort>
   DecodeHostAndPort(llvm::StringRef host_and_port);
@@ -185,6 +186,7 @@ class Socket : public IOObject {
 
   SocketProtocol m_protocol;
   NativeSocket m_socket;
+  WaitableHandle m_waitable_handle;
   bool m_should_close_fd;
 };
 

lldb/include/lldb/Host/windows/MainLoopWindows.h

@@ -37,11 +37,10 @@ class MainLoopWindows : public MainLoopBase {
   void Interrupt() override;
 
 private:
-  void ProcessReadObject(IOObject::WaitableHandle handle);
   llvm::Expected<size_t> Poll();
 
   struct FdInfo {
-    void *event;
+    lldb::IOObjectSP object_sp;
     Callback callback;
   };
   llvm::DenseMap<IOObject::WaitableHandle, FdInfo> m_read_fds;

lldb/include/lldb/Utility/IOObject.h

@@ -14,6 +14,7 @@
 #include <sys/types.h>
 
 #include "lldb/lldb-private.h"
+#include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
@@ -24,9 +25,9 @@ class IOObject {
     eFDTypeSocket, // Socket requiring send/recv
   };
 
-  // TODO: On Windows this should be a HANDLE, and wait should use
-  // WaitForMultipleObjects
-  typedef int WaitableHandle;
+  // A handle for integrating with the host event loop model.
+  using WaitableHandle = lldb::file_t;
+
   static const WaitableHandle kInvalidHandleValue;
 
   IOObject(FDType type) : m_fd_type(type) {}
@@ -40,6 +41,7 @@ class IOObject {
   FDType GetFdType() const { return m_fd_type; }
 
   virtual WaitableHandle GetWaitableHandle() = 0;
+  virtual bool HasReadableData() = 0;
 
 protected:
   FDType m_fd_type;

lldb/source/Host/common/File.cpp

@@ -118,6 +118,8 @@ IOObject::WaitableHandle File::GetWaitableHandle() {
   return IOObject::kInvalidHandleValue;
 }
 
+bool File::HasReadableData() { return false; }
+
 Status File::GetFileSpec(FileSpec &file_spec) const {
   file_spec.Clear();
   return std::error_code(ENOTSUP, std::system_category());
@@ -274,7 +276,23 @@ int NativeFile::GetDescriptor() const {
 }
 
 IOObject::WaitableHandle NativeFile::GetWaitableHandle() {
+#ifdef _WIN32
+  return (HANDLE)_get_osfhandle(GetDescriptor());
+#else
   return GetDescriptor();
+#endif
+}
+
+bool NativeFile::HasReadableData() {
+#ifdef _WIN32
+  DWORD available_bytes = 0;
+  return !PeekNamedPipe((HANDLE)_get_osfhandle(GetDescriptor()), NULL, 0, NULL,
+                        &available_bytes, NULL) ||
+         available_bytes > 0;
+#else
+  size_t buffer_size = 0;
+  return ioctl(GetDescriptor(), FIONREAD, buffer_size) != -1 && buffer_size > 0;
+#endif
 }
 
 FILE *NativeFile::GetStream() {

lldb/source/Host/common/Socket.cpp

@@ -31,8 +31,11 @@
 #include <netdb.h>
 #include <netinet/in.h>
 #include <netinet/tcp.h>
+#include <sys/ioctl.h>
 #include <sys/socket.h>
+#include <sys/stat.h>
 #include <sys/un.h>
+#include <termios.h>
 #include <unistd.h>
 #endif
 
@@ -169,7 +172,9 @@ bool Socket::FindProtocolByScheme(const char *scheme,
 
 Socket::Socket(SocketProtocol protocol, bool should_close)
     : IOObject(eFDTypeSocket), m_protocol(protocol),
-      m_socket(kInvalidSocketValue), m_should_close_fd(should_close) {}
+      m_socket(kInvalidSocketValue),
+      m_waitable_handle(IOObject::kInvalidHandleValue),
+      m_should_close_fd(should_close) {}
 
 Socket::~Socket() { Close(); }
 
@@ -313,8 +318,39 @@ Socket::DecodeHostAndPort(llvm::StringRef host_and_port) {
 }
 
 IOObject::WaitableHandle Socket::GetWaitableHandle() {
-  // TODO: On Windows, use WSAEventSelect
+#ifdef _WIN32
+  if (m_socket == kInvalidSocketValue)
+    return kInvalidHandleValue;
+
+  if (m_waitable_handle == kInvalidHandleValue) {
+    m_waitable_handle = WSACreateEvent();
+    assert(m_waitable_handle != WSA_INVALID_EVENT);
+    if (WSAEventSelect(m_socket, m_waitable_handle,
+                       FD_ACCEPT | FD_READ | FD_WRITE) != 0)
+      return kInvalidHandleValue;
+  }
+
+  return m_waitable_handle;
+#else
   return m_socket;
+#endif
+}
+
+bool Socket::HasReadableData() {
+#ifdef _WIN32
+  if (!IsValid() || m_waitable_handle == kInvalidHandleValue)
+    return false;
+
+  WSANETWORKEVENTS events;
+  if (WSAEnumNetworkEvents(m_socket, m_waitable_handle, &events) != 0)
+    return false;
+
+  return events.lNetworkEvents & FD_CLOSE ||
+         events.lNetworkEvents & FD_ACCEPT || events.lNetworkEvents & FD_READ;
+#else
+  size_t buffer_size = 0;
+  return ioctl(m_socket, FIONREAD, buffer_size) != -1 && buffer_size > 0;
+#endif
 }
 
 Status Socket::Read(void *buf, size_t &num_bytes) {
@@ -380,7 +416,14 @@ Status Socket::Close() {
   Log *log = GetLog(LLDBLog::Connection);
   LLDB_LOGF(log, "%p Socket::Close (fd = %" PRIu64 ")",
             static_cast<void *>(this), static_cast<uint64_t>(m_socket));
-
+#ifdef _WIN32
+  if (m_waitable_handle != kInvalidHandleValue) {
+    if (WSACloseEvent(m_waitable_handle) == 0)
+      m_waitable_handle = kInvalidHandleValue;
+    else
+      error = GetLastError();
+  }
+#endif
   bool success = CloseSocket(m_socket) == 0;
   // A reference to a FD was passed in, set it to an invalid value
   m_socket = kInvalidSocketValue;

lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp

@@ -276,7 +276,7 @@ size_t ConnectionFileDescriptor::Read(void *dst, size_t dst_len,
               "%p ConnectionFileDescriptor::Read()  fd = %" PRIu64
               ", dst = %p, dst_len = %" PRIu64 ") => %" PRIu64 ", error = %s",
               static_cast<void *>(this),
-              static_cast<uint64_t>(m_io_sp->GetWaitableHandle()),
+              static_cast<file_t>(m_io_sp->GetWaitableHandle()),
               static_cast<void *>(dst), static_cast<uint64_t>(dst_len),
               static_cast<uint64_t>(bytes_read), error.AsCString());
   }
@@ -380,7 +380,7 @@ size_t ConnectionFileDescriptor::Write(const void *src, size_t src_len,
               "%p ConnectionFileDescriptor::Write(fd = %" PRIu64
               ", src = %p, src_len = %" PRIu64 ") => %" PRIu64 " (error = %s)",
               static_cast<void *>(this),
-              static_cast<uint64_t>(m_io_sp->GetWaitableHandle()),
+              static_cast<file_t>(m_io_sp->GetWaitableHandle()),
               static_cast<const void *>(src), static_cast<uint64_t>(src_len),
               static_cast<uint64_t>(bytes_sent), error.AsCString());
   }
@@ -451,14 +451,17 @@ ConnectionFileDescriptor::BytesAvailable(const Timeout<std::micro> &timeout,
     if (timeout)
       select_helper.SetTimeout(*timeout);
 
-    select_helper.FDSetRead(handle);
+    // FIXME: Migrate to MainLoop.
 #if defined(_WIN32)
+    if (const auto *sock = static_cast<Socket *>(m_io_sp.get()))
+      select_helper.FDSetRead((socket_t)sock->GetNativeSocket());
     // select() won't accept pipes on Windows.  The entire Windows codepath
     // needs to be converted over to using WaitForMultipleObjects and event
     // HANDLEs, but for now at least this will allow ::select() to not return
     // an error.
     const bool have_pipe_fd = false;
 #else
+    select_helper.FDSetRead(handle);
     const bool have_pipe_fd = pipe_fd >= 0;
 #endif
     if (have_pipe_fd)
@@ -493,7 +496,12 @@ ConnectionFileDescriptor::BytesAvailable(const Timeout<std::micro> &timeout,
           break; // Lets keep reading to until we timeout
         }
       } else {
+#if defined(_WIN32)
+        if (const auto *sock = static_cast<Socket *>(m_io_sp.get());
+            select_helper.FDIsSetRead(sock->GetNativeSocket()))
+#else
         if (select_helper.FDIsSetRead(handle))
+#endif
           return eConnectionStatusSuccess;
 
         if (select_helper.FDIsSetRead(pipe_fd)) {