Removing disk file support and reverting unrelated changes.

ashgti · ashgti · commit 0f07158c89f0 · 2025-06-27T13:26:02.000-07:00
diff --git a/lldb/include/lldb/Host/windows/MainLoopWindows.h b/lldb/include/lldb/Host/windows/MainLoopWindows.h
@@ -31,17 +31,19 @@ class MainLoopWindows : public MainLoopBase {
 
   Status Run() override;
 
-  struct FdInfo {
-    FdInfo(intptr_t event, Callback callback)
-        : event(event), callback(callback) {}
-    virtual ~FdInfo() {}
+  class IOEvent {
+  public:
+    IOEvent(IOObject::WaitableHandle event) : m_event(event) {}
+    virtual ~IOEvent() {}
     virtual void WillPoll() {}
     virtual void DidPoll() {}
     virtual void Disarm() {}
-    intptr_t event;
-    Callback callback;
+    IOObject::WaitableHandle GetHandle() { return m_event; }
+
+  protected:
+    IOObject::WaitableHandle m_event;
   };
-  using FdInfoUP = std::unique_ptr<FdInfo>;
+  using IOEventUP = std::unique_ptr<IOEvent>;
 
 protected:
   void UnregisterReadObject(IOObject::WaitableHandle handle) override;
@@ -51,7 +53,11 @@ class MainLoopWindows : public MainLoopBase {
 private:
   llvm::Expected<size_t> Poll();
 
-  llvm::DenseMap<IOObject::WaitableHandle, FdInfoUP> m_read_fds;
+  struct FdInfo {
+    IOEventUP event;
+    Callback callback;
+  };
+  llvm::DenseMap<IOObject::WaitableHandle, FdInfo> m_read_fds;
   void *m_interrupt_event;
 };
 
diff --git a/lldb/source/Host/common/Socket.cpp b/lldb/source/Host/common/Socket.cpp
@@ -31,11 +31,8 @@
 #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
 
@@ -172,8 +169,7 @@ 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_should_close_fd(should_close) {}
 
 Socket::~Socket() { Close(); }
 
@@ -383,6 +379,7 @@ 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));
+
   bool success = CloseSocket(m_socket) == 0;
   // A reference to a FD was passed in, set it to an invalid value
   m_socket = kInvalidSocketValue;
diff --git a/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp b/lldb/source/Host/posix/ConnectionFileDescriptorPosix.cpp
@@ -452,16 +452,14 @@ ConnectionFileDescriptor::BytesAvailable(const Timeout<std::micro> &timeout,
       select_helper.SetTimeout(*timeout);
 
     // FIXME: Migrate to MainLoop.
+    select_helper.FDSetRead((lldb::socket_t)handle);
 #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)
@@ -496,12 +494,7 @@ 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
+        if (select_helper.FDIsSetRead((lldb::socket_t)handle))
           return eConnectionStatusSuccess;
 
         if (select_helper.FDIsSetRead(pipe_fd)) {
diff --git a/lldb/source/Host/windows/MainLoopWindows.cpp b/lldb/source/Host/windows/MainLoopWindows.cpp
@@ -24,9 +24,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-namespace {
-
-DWORD ToTimeout(std::optional<MainLoopWindows::TimePoint> point) {
+static DWORD ToTimeout(std::optional<MainLoopWindows::TimePoint> point) {
   using namespace std::chrono;
 
   if (!point)
@@ -36,40 +34,39 @@ DWORD ToTimeout(std::optional<MainLoopWindows::TimePoint> point) {
   return ceil<milliseconds>(dur).count();
 }
 
-class PipeFdInfo : public MainLoopWindows::FdInfo {
+namespace {
+
+class PipeEvent : public MainLoopWindows::IOEvent {
 public:
-  explicit PipeFdInfo(HANDLE handle, MainLoopBase::Callback callback)
-      : FdInfo((intptr_t)CreateEventW(NULL, /*bManualReset=*/FALSE,
-                                      /*bInitialState=*/FALSE, NULL),
-               callback),
-        handle(handle), ready(CreateEventW(NULL, /*bManualReset=*/FALSE,
-                                           /*bInitialState=*/FALSE, NULL)) {
+  explicit PipeEvent(HANDLE handle)
+      : IOEvent((IOObject::WaitableHandle)CreateEventW(NULL, /*bManualReset=*/FALSE,
+                                             /*bInitialState=*/FALSE, NULL)),
+        m_handle(handle), m_ready(CreateEventW(NULL, /*bManualReset=*/FALSE,
+                                               /*bInitialState=*/FALSE, NULL)) {
     assert(event && ready);
   }
 
-  ~PipeFdInfo() override {
-    if (monitor_thread.joinable()) {
-      stopped = true;
-      SetEvent(ready);
+  ~PipeEvent() override {
+    if (m_monitor_thread.joinable()) {
+      m_stopped = true;
+      SetEvent(m_ready);
       // Keep trying to cancel ReadFile() until the thread exits.
       do {
-        CancelIoEx((HANDLE)handle, /*lpOverlapped=*/NULL);
-      } while (WaitForSingleObject(monitor_thread.native_handle(), 1) ==
+        CancelIoEx((HANDLE)m_handle, /*lpOverlapped=*/NULL);
+      } while (WaitForSingleObject(m_monitor_thread.native_handle(), 1) ==
                WAIT_TIMEOUT);
-      monitor_thread.join();
+      m_monitor_thread.join();
     }
-    CloseHandle((HANDLE)event);
-    CloseHandle(ready);
+    CloseHandle((HANDLE)m_event);
+    CloseHandle(m_ready);
   }
 
-  void WillPoll() override { 
-    if (!monitor_thread.joinable())
-      monitor_thread = std::thread(&PipeFdInfo::Monitor, this);
+  void WillPoll() override {
+    if (!m_monitor_thread.joinable())
+      m_monitor_thread = std::thread(&PipeEvent::Monitor, this);
   }
 
-  void Disarm() override {
-    SetEvent(ready);
-  }
+  void Disarm() override { SetEvent(m_ready); }
 
   /// Monitors the handle performing a zero byte read to determine when data is
   /// avaiable.
@@ -82,16 +79,17 @@ class PipeFdInfo : public MainLoopWindows::FdInfo {
       // available in the pipe. The pipe must be PIPE_WAIT or this thread
       // will spin.
       BOOL success =
-          ReadFile(handle, buf, /*nNumberOfBytesToRead=*/0, &bytes_read, &ov);
+          ReadFile(m_handle, buf, /*nNumberOfBytesToRead=*/0, &bytes_read, &ov);
       DWORD bytes_available = 0;
       DWORD err = GetLastError();
       if (!success && err == ERROR_IO_PENDING) {
-        success = GetOverlappedResult(handle, &ov, &bytes_read,
+        success = GetOverlappedResult(m_handle, &ov, &bytes_read,
                                       /*bWait=*/TRUE);
         err = GetLastError();
       }
       if (success) {
-        success = PeekNamedPipe(handle, NULL, 0, NULL, &bytes_available, NULL);
+        success =
+            PeekNamedPipe(m_handle, NULL, 0, NULL, &bytes_available, NULL);
         err = GetLastError();
       }
       if (success) {
@@ -108,51 +106,45 @@ class PipeFdInfo : public MainLoopWindows::FdInfo {
         continue;
       }
 
-      SetEvent((HANDLE)event);
+      SetEvent((HANDLE)m_event);
 
       // Wait until the current read is consumed before doing the next read.
-      WaitForSingleObject(ready, INFINITE);
-    } while (!stopped);
+      WaitForSingleObject(m_ready, INFINITE);
+    } while (!m_stopped);
   }
 
-  HANDLE handle;
-  HANDLE ready;
-  std::thread monitor_thread;
-  std::atomic<bool> stopped = false;
+private:
+  HANDLE m_handle;
+  HANDLE m_ready;
+  std::thread m_monitor_thread;
+  std::atomic<bool> m_stopped = false;
 };
 
-class SocketFdInfo : public MainLoopWindows::FdInfo {
+class SocketEvent : public MainLoopWindows::IOEvent {
 public:
-  explicit SocketFdInfo(SOCKET socket, MainLoopBase::Callback callback)
-      : FdInfo((intptr_t)WSACreateEvent(), callback), socket(socket) {
+  explicit SocketEvent(SOCKET socket)
+      : IOEvent((IOObject::WaitableHandle)WSACreateEvent()), m_socket(socket) {
     assert(event != WSA_INVALID_EVENT);
   }
 
-  ~SocketFdInfo() override { WSACloseEvent((HANDLE)event); }
+  ~SocketEvent() override { WSACloseEvent((HANDLE)m_event); }
 
   void WillPoll() {
-    int result = WSAEventSelect(socket, (HANDLE)event, FD_READ | FD_ACCEPT | FD_CLOSE);
+    int result =
+        WSAEventSelect(m_socket, (HANDLE)m_event, FD_READ | FD_ACCEPT | FD_CLOSE);
     assert(result == 0);
     UNUSED_IF_ASSERT_DISABLED(result);
   }
 
   void DidPoll() {
-    int result = WSAEventSelect(socket, WSA_INVALID_EVENT, 0);
+    int result = WSAEventSelect(m_socket, WSA_INVALID_EVENT, 0);
     assert(result == 0);
     UNUSED_IF_ASSERT_DISABLED(result);
   }
 
-  void Disarm() override {
-    WSAResetEvent((HANDLE)event);
-  }
-
-  SOCKET socket;
-};
+  void Disarm() override { WSAResetEvent((HANDLE)m_event); }
 
-class FileFdInfo : public MainLoopWindows::FdInfo {
-public:
-  explicit FileFdInfo(HANDLE handle, MainLoopBase::Callback callback)
-      : FdInfo((intptr_t)handle, callback) {}
+  SOCKET m_socket;
 };
 
 } // namespace
@@ -173,8 +165,8 @@ llvm::Expected<size_t> MainLoopWindows::Poll() {
   std::vector<HANDLE> events;
   events.reserve(m_read_fds.size() + 1);
   for (auto &[_, fd_info] : m_read_fds) {
-    fd_info->WillPoll();
-    events.push_back((HANDLE)fd_info->event);
+    fd_info.event->WillPoll();
+    events.push_back((HANDLE)fd_info.event->GetHandle());
   }
   events.push_back(m_interrupt_event);
 
@@ -183,7 +175,7 @@ llvm::Expected<size_t> MainLoopWindows::Poll() {
                                ToTimeout(GetNextWakeupTime()), FALSE);
 
   for (auto &[_, fd_info] : m_read_fds) {
-    fd_info->DidPoll();
+    fd_info.event->DidPoll();
   }
 
   if (result >= WSA_WAIT_EVENT_0 && result < WSA_WAIT_EVENT_0 + events.size())
@@ -215,23 +207,16 @@ MainLoopWindows::RegisterReadObject(const IOObjectSP &object_sp,
   }
 
   if (object_sp->GetFdType() == IOObject::eFDTypeSocket)
-    m_read_fds[waitable_handle] =
-        std::make_unique<SocketFdInfo>((SOCKET)waitable_handle, callback);
-  else
-    switch (GetFileType(waitable_handle)) {
-    case FILE_TYPE_PIPE:
-      m_read_fds[waitable_handle] =
-          std::make_unique<PipeFdInfo>((HANDLE)waitable_handle, callback);
-      break;
-    case FILE_TYPE_DISK:
-      m_read_fds[waitable_handle] =
-          std::make_unique<FileFdInfo>((HANDLE)waitable_handle, callback);
-      break;
-    default:
-      error = Status::FromErrorStringWithFormat("Unsupported file type %d",
-                                                GetFileType(waitable_handle));
-      return nullptr;
-    }
+    m_read_fds[waitable_handle] = {
+        std::make_unique<SocketEvent>((SOCKET)waitable_handle), callback};
+  else if (GetFileType(waitable_handle) == FILE_TYPE_PIPE)
+    m_read_fds[waitable_handle] = {
+        std::make_unique<PipeEvent>((HANDLE)waitable_handle), callback};
+  else {
+    error = Status::FromErrorStringWithFormat("Unsupported file type %d",
+                                              GetFileType(waitable_handle));
+    return nullptr;
+  }
 
   return CreateReadHandle(object_sp);
 }
@@ -254,8 +239,8 @@ Status MainLoopWindows::Run() {
 
     if (*signaled_event < m_read_fds.size()) {
       auto &KV = *std::next(m_read_fds.begin(), *signaled_event);
-      KV.second->Disarm();
-      KV.second->callback(*this); // Do the work.
+      KV.second.event->Disarm();
+      KV.second.callback(*this); // Do the work.
     } else {
       assert(*signaled_event == m_read_fds.size());
       WSAResetEvent(m_interrupt_event);
diff --git a/lldb/unittests/Host/MainLoopTest.cpp b/lldb/unittests/Host/MainLoopTest.cpp
