Create a ConnectionGenericFile class for Windows.

This is the first step in getting ConnectionFileDescriptor ported
to Windows. It implements a connection against a disk file for
windows. This supports connection strings of the form file://PATH
which are currently supported only on posix platforms in
ConnectionFileDescriptor.

Reviewed by: Greg Clayton
Differential Revision: http://reviews.llvm.org/D5608

llvm-svn: 219145

lldb/include/lldb/Core/Connection.h

@@ -46,6 +46,8 @@ public:
     virtual
     ~Connection ();
 
+    static Connection *CreateDefaultConnection(const char *url);
+
     //------------------------------------------------------------------
     /// Connect using the connect string \a url.
     ///

lldb/include/lldb/Host/windows/ConnectionGenericFileWindows.h

@@ -0,0 +1,64 @@
+//===-- ConnectionGenericFileWindows.h --------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_Host_windows_ConnectionGenericFileWindows_h_
+#define liblldb_Host_windows_ConnectionGenericFileWindows_h_
+
+#include "lldb/Core/Connection.h"
+#include "lldb/Host/windows/windows.h"
+#include "lldb/lldb-types.h"
+
+namespace lldb_private
+{
+
+class Error;
+
+class ConnectionGenericFile : public lldb_private::Connection
+{
+  public:
+    ConnectionGenericFile();
+
+    ConnectionGenericFile(lldb::file_t file, bool owns_file);
+
+    virtual ~ConnectionGenericFile();
+
+    virtual bool IsConnected() const;
+
+    virtual lldb::ConnectionStatus Connect(const char *s, Error *error_ptr);
+
+    virtual lldb::ConnectionStatus Disconnect(Error *error_ptr);
+
+    virtual size_t Read(void *dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus &status, Error *error_ptr);
+
+    virtual size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status, Error *error_ptr);
+
+    bool InterruptRead();
+
+  protected:
+    OVERLAPPED m_overlapped;
+    HANDLE m_file;
+    HANDLE m_event_handles[2];
+    bool m_owns_file;
+    LARGE_INTEGER m_file_position;
+
+    enum
+    {
+        kBytesAvailableEvent,
+        kInterruptEvent
+    };
+
+  private:
+    void InitializeEventHandles();
+    void IncrementFilePointer(DWORD amount);
+
+    DISALLOW_COPY_AND_ASSIGN(ConnectionGenericFile);
+};
+}
+
+#endif

lldb/include/lldb/lldb-types.h

@@ -51,6 +51,9 @@ namespace lldb
     typedef void*               rwlock_t;
     typedef void*               process_t;                  // Process type is HANDLE
     typedef void*               thread_t;                   // Host thread type
+    typedef void*               file_t;                     // Host file type
+    typedef void*               pipe_t;                     // Host pipe type
+    typedef unsigned int __w64  socket_t;                   // Host socket type
     typedef uint32_t            thread_key_t;
     typedef void*               thread_arg_t;               // Host thread argument type
     typedef unsigned            thread_result_t;            // Host thread result type
@@ -71,6 +74,9 @@ namespace lldb
     typedef pthread_rwlock_t    rwlock_t;
     typedef uint64_t            process_t;                  // Process type is just a pid.
     typedef pthread_t           thread_t;                   // Host thread type
+    typedef int                 file_t;                     // Host file type
+    typedef int                 pipe_t;                     // Host pipe type
+    typedef int                 socket_t;                   // Host socket type
     typedef pthread_key_t       thread_key_t;
     typedef void *              thread_arg_t;               // Host thread argument type
     typedef void *              thread_result_t;            // Host thread result type

lldb/source/API/SBCommunication.cpp

@@ -71,7 +71,7 @@ SBCommunication::Connect (const char *url)
     if (m_opaque)
     {
         if (!m_opaque->HasConnection ())
-            m_opaque->SetConnection (new ConnectionFileDescriptor());
+            m_opaque->SetConnection(Connection::CreateDefaultConnection(url));
         return m_opaque->Connect (url, NULL);
     }
     return eConnectionStatusNoConnection;

lldb/source/Core/Connection.cpp

@@ -13,6 +13,12 @@
 // Project includes
 #include "lldb/Core/Connection.h"
 
+#if defined(_WIN32)
+#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
+#endif
+
+#include "lldb/Host/ConnectionFileDescriptor.h"
+
 using namespace lldb_private;
 
 Connection::Connection ()
@@ -22,3 +28,13 @@ Connection::Connection ()
 Connection::~Connection ()
 {
 }
+
+Connection *
+Connection::CreateDefaultConnection(const char *url)
+{
+#if defined(_WIN32)
+    if (strstr(url, "file://") == url)
+        return new ConnectionGenericFile();
+#endif
+    return new ConnectionFileDescriptor();
+}

lldb/source/Host/CMakeLists.txt

@@ -40,6 +40,7 @@ add_host_subdirectory(posix
 if (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_host_subdirectory(windows
     windows/Condition.cpp
+    windows/ConnectionGenericFileWindows.cpp
     windows/EditLineWin.cpp
     windows/FileSystem.cpp
     windows/Host.cpp

lldb/source/Host/windows/ConnectionGenericFileWindows.cpp

@@ -0,0 +1,337 @@
+//===-- ConnectionGenericFileWindows.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/Core/Error.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Host/TimeValue.h"
+#include "lldb/Host/windows/ConnectionGenericFileWindows.h"
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace
+{
+// This is a simple helper class to package up the information needed to return from a Read/Write
+// operation function.  Since there is alot of code to be run before exit regardless of whether the
+// operation succeeded or failed, combined with many possible return paths, this is the cleanest
+// way to represent it.
+class ReturnInfo
+{
+  public:
+    void
+    Set(size_t bytes, ConnectionStatus status, DWORD error_code)
+    {
+        m_error.SetError(error_code, eErrorTypeWin32);
+        m_bytes = bytes;
+        m_status = status;
+    }
+
+    void
+    Set(size_t bytes, ConnectionStatus status, llvm::StringRef error_msg)
+    {
+        m_error.SetErrorString(error_msg.data());
+        m_bytes = bytes;
+        m_status = status;
+    }
+
+    size_t
+    GetBytes() const
+    {
+        return m_bytes;
+    }
+    ConnectionStatus
+    GetStatus() const
+    {
+        return m_status;
+    }
+    const Error &
+    GetError() const
+    {
+        return m_error;
+    }
+
+  private:
+    Error m_error;
+    size_t m_bytes;
+    ConnectionStatus m_status;
+};
+}
+
+ConnectionGenericFile::ConnectionGenericFile()
+    : m_file(INVALID_HANDLE_VALUE)
+    , m_owns_file(false)
+{
+    ::ZeroMemory(&m_overlapped, sizeof(m_overlapped));
+    ::ZeroMemory(&m_file_position, sizeof(m_file_position));
+    InitializeEventHandles();
+}
+
+ConnectionGenericFile::ConnectionGenericFile(lldb::file_t file, bool owns_file)
+    : m_file(file)
+    , m_owns_file(owns_file)
+{
+    ::ZeroMemory(&m_overlapped, sizeof(m_overlapped));
+    ::ZeroMemory(&m_file_position, sizeof(m_file_position));
+    InitializeEventHandles();
+}
+
+ConnectionGenericFile::~ConnectionGenericFile()
+{
+    if (m_owns_file && IsConnected())
+        ::CloseHandle(m_file);
+
+    ::CloseHandle(m_event_handles[kBytesAvailableEvent]);
+    ::CloseHandle(m_event_handles[kInterruptEvent]);
+}
+
+void
+ConnectionGenericFile::InitializeEventHandles()
+{
+    m_event_handles[kInterruptEvent] = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+    // Note, we should use a manual reset event for the hEvent argument of the OVERLAPPED.  This
+    // is because both WaitForMultipleObjects and GetOverlappedResult (if you set the bWait
+    // argument to TRUE) will wait for the event to be signalled.  If we use an auto-reset event,
+    // WaitForMultipleObjects will reset the event, return successfully, and then
+    // GetOverlappedResult will block since the event is no longer signalled.
+    m_event_handles[kBytesAvailableEvent] = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+}
+
+bool
+ConnectionGenericFile::IsConnected() const
+{
+    return m_file && (m_file != INVALID_HANDLE_VALUE);
+}
+
+lldb::ConnectionStatus
+ConnectionGenericFile::Connect(const char *s, Error *error_ptr)
+{
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+    if (log)
+        log->Printf("%p ConnectionGenericFile::Connect (url = '%s')", static_cast<void *>(this), s);
+
+    if (strstr(s, "file://") != s)
+    {
+        if (error_ptr)
+            error_ptr->SetErrorStringWithFormat("unsupported connection URL: '%s'", s);
+        return eConnectionStatusError;
+    }
+
+    if (IsConnected())
+    {
+        ConnectionStatus status = Disconnect(error_ptr);
+        if (status != eConnectionStatusSuccess)
+            return status;
+    }
+
+    // file://PATH
+    const char *path = s + strlen("file://");
+    // Open the file for overlapped access.  If it does not exist, create it.  We open it overlapped
+    // so that we can issue asynchronous reads and then use WaitForMultipleObjects to allow the read
+    // to be interrupted by an event object.
+    m_file = ::CreateFile(path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_FLAG_OVERLAPPED, NULL);
+    if (m_file == INVALID_HANDLE_VALUE)
+    {
+        if (error_ptr)
+            error_ptr->SetError(::GetLastError(), eErrorTypeWin32);
+        return eConnectionStatusError;
+    }
+
+    m_owns_file = true;
+    return eConnectionStatusSuccess;
+}
+
+lldb::ConnectionStatus
+ConnectionGenericFile::Disconnect(Error *error_ptr)
+{
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+    if (log)
+        log->Printf("%p ConnectionGenericFile::Disconnect (url = '%s')", static_cast<void *>(this), s);
+
+    if (!IsConnected())
+        return eConnectionStatusSuccess;
+
+    // Reset the handle so that after we unblock any pending reads, subsequent calls to Read() will
+    // see a disconnected state.
+    HANDLE old_file = m_file;
+    m_file = INVALID_HANDLE_VALUE;
+
+    // Set the disconnect event so that any blocking reads unblock, then cancel any pending IO operations.
+    ::CancelIoEx(old_file, &m_overlapped);
+
+    // Close the file handle if we owned it, but don't close the event handles.  We could always
+    // reconnect with the same Connection instance.
+    if (m_owns_file)
+        ::CloseHandle(old_file);
+
+    ::ZeroMemory(&m_file_position, sizeof(m_file_position));
+    m_owns_file = false;
+    return eConnectionStatusSuccess;
+}
+
+size_t
+ConnectionGenericFile::Read(void *dst, size_t dst_len, uint32_t timeout_usec, lldb::ConnectionStatus &status, Error *error_ptr)
+{
+    ReturnInfo return_info;
+
+    if (error_ptr)
+        error_ptr->Clear();
+
+    if (!IsConnected())
+    {
+        return_info.Set(0, eConnectionStatusNoConnection, ERROR_INVALID_HANDLE);
+        goto finish;
+    }
+
+    m_overlapped.hEvent = m_event_handles[kBytesAvailableEvent];
+
+    BOOL result = ::ReadFile(m_file, dst, dst_len, NULL, &m_overlapped);
+    if (result || ::GetLastError() == ERROR_IO_PENDING)
+    {
+        if (!result)
+        {
+            // The expected return path.  The operation is pending.  Wait for the operation to complete
+            // or be interrupted.
+            TimeValue time_value;
+            time_value.OffsetWithMicroSeconds(timeout_usec);
+            DWORD milliseconds = time_value.milliseconds();
+            result = ::WaitForMultipleObjects(llvm::array_lengthof(m_event_handles), m_event_handles, FALSE, milliseconds);
+            // All of the events are manual reset events, so make sure we reset them to non-signalled.
+            switch (result)
+            {
+                case WAIT_OBJECT_0 + kBytesAvailableEvent:
+                    break;
+                case WAIT_OBJECT_0 + kInterruptEvent:
+                    return_info.Set(0, eConnectionStatusInterrupted, 0);
+                    goto finish;
+                case WAIT_TIMEOUT:
+                    return_info.Set(0, eConnectionStatusTimedOut, 0);
+                    goto finish;
+                case WAIT_FAILED:
+                    return_info.Set(0, eConnectionStatusError, ::GetLastError());
+                    goto finish;
+            }
+        }
+        // The data is ready.  Figure out how much was read and return;
+        DWORD bytes_read = 0;
+        if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_read, FALSE))
+        {
+            DWORD result_error = ::GetLastError();
+            // ERROR_OPERATION_ABORTED occurs when someone calls Disconnect() during a blocking read.
+            // This triggers a call to CancelIoEx, which causes the operation to complete and the
+            // result to be ERROR_OPERATION_ABORTED.
+            if (result_error == ERROR_HANDLE_EOF || result_error == ERROR_OPERATION_ABORTED)
+                return_info.Set(bytes_read, eConnectionStatusEndOfFile, 0);
+            else
+                return_info.Set(bytes_read, eConnectionStatusError, result_error);
+        }
+        else if (bytes_read == 0)
+            return_info.Set(bytes_read, eConnectionStatusEndOfFile, 0);
+        else
+            return_info.Set(bytes_read, eConnectionStatusSuccess, 0);
+
+        goto finish;
+    }
+
+    // An unknown error occured.  Fail out.
+    return_info.Set(0, eConnectionStatusError, ::GetLastError());
+    goto finish;
+
+finish:
+    status = return_info.GetStatus();
+    if (error_ptr)
+        *error_ptr = return_info.GetError();
+
+    // kBytesAvailableEvent is a manual reset event.  Make sure it gets reset here so that any
+    // subsequent operations don't immediately see bytes available.
+    ResetEvent(m_event_handles[kBytesAvailableEvent]);
+
+    IncrementFilePointer(return_info.GetBytes());
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+    if (log)
+    {
+        log->Printf("%" PRIxPTR " ConnectionGenericFile::Read()  handle = %" PRIxPTR ", dst = %" PRIxPTR ", dst_len = %" PRIu64
+                    ") => %" PRIu64 ", error = %s",
+                    this, m_file, dst, static_cast<uint64_t>(dst_len), static_cast<uint64_t>(return_info.GetBytes()),
+                    return_info.GetError().AsCString());
+    }
+
+    return return_info.GetBytes();
+}
+
+size_t
+ConnectionGenericFile::Write(const void *src, size_t src_len, lldb::ConnectionStatus &status, Error *error_ptr)
+{
+    ReturnInfo return_info;
+
+    if (error_ptr)
+        error_ptr->Clear();
+
+    if (!IsConnected())
+    {
+        return_info.Set(0, eConnectionStatusNoConnection, ERROR_INVALID_HANDLE);
+        goto finish;
+    }
+
+    m_overlapped.hEvent = NULL;
+
+    // Writes are not interruptible like reads are, so just block until it's done.
+    BOOL result = ::WriteFile(m_file, src, src_len, NULL, &m_overlapped);
+    if (!result && ::GetLastError() != ERROR_IO_PENDING)
+    {
+        return_info.Set(0, eConnectionStatusError, ::GetLastError());
+        goto finish;
+    }
+
+    DWORD bytes_written = 0;
+    if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_written, TRUE))
+    {
+        return_info.Set(bytes_written, eConnectionStatusError, ::GetLastError());
+        goto finish;
+    }
+
+    return_info.Set(bytes_written, eConnectionStatusSuccess, 0);
+    goto finish;
+
+finish:
+    status = return_info.GetStatus();
+    if (error_ptr)
+        *error_ptr = return_info.GetError();
+
+    IncrementFilePointer(return_info.GetBytes());
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
+    if (log)
+    {
+        log->Printf("%" PRIxPTR " ConnectionGenericFile::Write()  handle = %" PRIxPTR ", src = %" PRIxPTR ", src_len = %" PRIu64
+                    ") => %" PRIu64 ", error = %s",
+                    this, m_file, src, static_cast<uint64_t>(src_len), static_cast<uint64_t>(return_info.GetBytes()),
+                    return_info.GetError().AsCString());
+    }
+    return return_info.GetBytes();
+}
+
+bool
+ConnectionGenericFile::InterruptRead()
+{
+    return ::SetEvent(m_event_handles[kInterruptEvent]);
+}
+
+void
+ConnectionGenericFile::IncrementFilePointer(DWORD amount)
+{
+    LARGE_INTEGER old_pos;
+    old_pos.HighPart = m_overlapped.OffsetHigh;
+    old_pos.LowPart = m_overlapped.Offset;
+    old_pos.QuadPart += amount;
+    m_overlapped.Offset = old_pos.LowPart;
+    m_overlapped.OffsetHigh = old_pos.HighPart;
+}