1 //===-- ConnectionGenericFileWindows.cpp ------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Host/windows/ConnectionGenericFileWindows.h"
10 #include "lldb/Utility/Log.h"
11 #include "lldb/Utility/Status.h"
12 #include "lldb/Utility/Timeout.h"
13 
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/Support/ConvertUTF.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 
21 namespace {
22 // This is a simple helper class to package up the information needed to return
23 // from a Read/Write operation function.  Since there is a lot of code to be
24 // run before exit regardless of whether the operation succeeded or failed,
25 // combined with many possible return paths, this is the cleanest way to
26 // represent it.
27 class ReturnInfo {
28 public:
29   void Set(size_t bytes, ConnectionStatus status, DWORD error_code) {
30     m_error.SetError(error_code, eErrorTypeWin32);
31     m_bytes = bytes;
32     m_status = status;
33   }
34 
35   void Set(size_t bytes, ConnectionStatus status, llvm::StringRef error_msg) {
36     m_error.SetErrorString(error_msg.data());
37     m_bytes = bytes;
38     m_status = status;
39   }
40 
41   size_t GetBytes() const { return m_bytes; }
42   ConnectionStatus GetStatus() const { return m_status; }
43   const Status &GetError() const { return m_error; }
44 
45 private:
46   Status m_error;
47   size_t m_bytes;
48   ConnectionStatus m_status;
49 };
50 }
51 
52 ConnectionGenericFile::ConnectionGenericFile()
53     : m_file(INVALID_HANDLE_VALUE), m_owns_file(false) {
54   ::ZeroMemory(&m_overlapped, sizeof(m_overlapped));
55   ::ZeroMemory(&m_file_position, sizeof(m_file_position));
56   InitializeEventHandles();
57 }
58 
59 ConnectionGenericFile::ConnectionGenericFile(lldb::file_t file, bool owns_file)
60     : m_file(file), m_owns_file(owns_file) {
61   ::ZeroMemory(&m_overlapped, sizeof(m_overlapped));
62   ::ZeroMemory(&m_file_position, sizeof(m_file_position));
63   InitializeEventHandles();
64 }
65 
66 ConnectionGenericFile::~ConnectionGenericFile() {
67   if (m_owns_file && IsConnected())
68     ::CloseHandle(m_file);
69 
70   ::CloseHandle(m_event_handles[kBytesAvailableEvent]);
71   ::CloseHandle(m_event_handles[kInterruptEvent]);
72 }
73 
74 void ConnectionGenericFile::InitializeEventHandles() {
75   m_event_handles[kInterruptEvent] = CreateEvent(NULL, FALSE, FALSE, NULL);
76 
77   // Note, we should use a manual reset event for the hEvent argument of the
78   // OVERLAPPED.  This is because both WaitForMultipleObjects and
79   // GetOverlappedResult (if you set the bWait argument to TRUE) will wait for
80   // the event to be signalled.  If we use an auto-reset event,
81   // WaitForMultipleObjects will reset the event, return successfully, and then
82   // GetOverlappedResult will block since the event is no longer signalled.
83   m_event_handles[kBytesAvailableEvent] =
84       ::CreateEvent(NULL, TRUE, FALSE, NULL);
85 }
86 
87 bool ConnectionGenericFile::IsConnected() const {
88   return m_file && (m_file != INVALID_HANDLE_VALUE);
89 }
90 
91 lldb::ConnectionStatus ConnectionGenericFile::Connect(llvm::StringRef path,
92                                                       Status *error_ptr) {
93   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
94   LLDB_LOGF(log, "%p ConnectionGenericFile::Connect (url = '%s')",
95             static_cast<void *>(this), path.str().c_str());
96 
97   if (!path.consume_front("file://")) {
98     if (error_ptr)
99       error_ptr->SetErrorStringWithFormat("unsupported connection URL: '%s'",
100                                           path.str().c_str());
101     return eConnectionStatusError;
102   }
103 
104   if (IsConnected()) {
105     ConnectionStatus status = Disconnect(error_ptr);
106     if (status != eConnectionStatusSuccess)
107       return status;
108   }
109 
110   // Open the file for overlapped access.  If it does not exist, create it.  We
111   // open it overlapped so that we can issue asynchronous reads and then use
112   // WaitForMultipleObjects to allow the read to be interrupted by an event
113   // object.
114   std::wstring wpath;
115   if (!llvm::ConvertUTF8toWide(path, wpath)) {
116     if (error_ptr)
117       error_ptr->SetError(1, eErrorTypeGeneric);
118     return eConnectionStatusError;
119   }
120   m_file = ::CreateFileW(wpath.c_str(), GENERIC_READ | GENERIC_WRITE,
121                          FILE_SHARE_READ, NULL, OPEN_ALWAYS,
122                          FILE_FLAG_OVERLAPPED, NULL);
123   if (m_file == INVALID_HANDLE_VALUE) {
124     if (error_ptr)
125       error_ptr->SetError(::GetLastError(), eErrorTypeWin32);
126     return eConnectionStatusError;
127   }
128 
129   m_owns_file = true;
130   m_uri.assign(path);
131   return eConnectionStatusSuccess;
132 }
133 
134 lldb::ConnectionStatus ConnectionGenericFile::Disconnect(Status *error_ptr) {
135   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
136   LLDB_LOGF(log, "%p ConnectionGenericFile::Disconnect ()",
137             static_cast<void *>(this));
138 
139   if (!IsConnected())
140     return eConnectionStatusSuccess;
141 
142   // Reset the handle so that after we unblock any pending reads, subsequent
143   // calls to Read() will see a disconnected state.
144   HANDLE old_file = m_file;
145   m_file = INVALID_HANDLE_VALUE;
146 
147   // Set the disconnect event so that any blocking reads unblock, then cancel
148   // any pending IO operations.
149   ::CancelIoEx(old_file, &m_overlapped);
150 
151   // Close the file handle if we owned it, but don't close the event handles.
152   // We could always reconnect with the same Connection instance.
153   if (m_owns_file)
154     ::CloseHandle(old_file);
155 
156   ::ZeroMemory(&m_file_position, sizeof(m_file_position));
157   m_owns_file = false;
158   m_uri.clear();
159   return eConnectionStatusSuccess;
160 }
161 
162 size_t ConnectionGenericFile::Read(void *dst, size_t dst_len,
163                                    const Timeout<std::micro> &timeout,
164                                    lldb::ConnectionStatus &status,
165                                    Status *error_ptr) {
166   ReturnInfo return_info;
167   BOOL result = 0;
168   DWORD bytes_read = 0;
169 
170   if (error_ptr)
171     error_ptr->Clear();
172 
173   if (!IsConnected()) {
174     return_info.Set(0, eConnectionStatusNoConnection, ERROR_INVALID_HANDLE);
175     goto finish;
176   }
177 
178   m_overlapped.hEvent = m_event_handles[kBytesAvailableEvent];
179 
180   result = ::ReadFile(m_file, dst, dst_len, NULL, &m_overlapped);
181   if (result || ::GetLastError() == ERROR_IO_PENDING) {
182     if (!result) {
183       // The expected return path.  The operation is pending.  Wait for the
184       // operation to complete or be interrupted.
185       DWORD milliseconds =
186           timeout
187               ? std::chrono::duration_cast<std::chrono::milliseconds>(*timeout)
188                     .count()
189               : INFINITE;
190       DWORD wait_result =
191           ::WaitForMultipleObjects(llvm::array_lengthof(m_event_handles),
192                                    m_event_handles, FALSE, milliseconds);
193       // All of the events are manual reset events, so make sure we reset them
194       // to non-signalled.
195       switch (wait_result) {
196       case WAIT_OBJECT_0 + kBytesAvailableEvent:
197         break;
198       case WAIT_OBJECT_0 + kInterruptEvent:
199         return_info.Set(0, eConnectionStatusInterrupted, 0);
200         goto finish;
201       case WAIT_TIMEOUT:
202         return_info.Set(0, eConnectionStatusTimedOut, 0);
203         goto finish;
204       case WAIT_FAILED:
205         return_info.Set(0, eConnectionStatusError, ::GetLastError());
206         goto finish;
207       }
208     }
209     // The data is ready.  Figure out how much was read and return;
210     if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_read, FALSE)) {
211       DWORD result_error = ::GetLastError();
212       // ERROR_OPERATION_ABORTED occurs when someone calls Disconnect() during
213       // a blocking read. This triggers a call to CancelIoEx, which causes the
214       // operation to complete and the result to be ERROR_OPERATION_ABORTED.
215       if (result_error == ERROR_HANDLE_EOF ||
216           result_error == ERROR_OPERATION_ABORTED ||
217           result_error == ERROR_BROKEN_PIPE)
218         return_info.Set(bytes_read, eConnectionStatusEndOfFile, 0);
219       else
220         return_info.Set(bytes_read, eConnectionStatusError, result_error);
221     } else if (bytes_read == 0)
222       return_info.Set(bytes_read, eConnectionStatusEndOfFile, 0);
223     else
224       return_info.Set(bytes_read, eConnectionStatusSuccess, 0);
225 
226     goto finish;
227   } else if (::GetLastError() == ERROR_BROKEN_PIPE) {
228     // The write end of a pipe was closed.  This is equivalent to EOF.
229     return_info.Set(0, eConnectionStatusEndOfFile, 0);
230   } else {
231     // An unknown error occurred.  Fail out.
232     return_info.Set(0, eConnectionStatusError, ::GetLastError());
233   }
234   goto finish;
235 
236 finish:
237   status = return_info.GetStatus();
238   if (error_ptr)
239     *error_ptr = return_info.GetError();
240 
241   // kBytesAvailableEvent is a manual reset event.  Make sure it gets reset
242   // here so that any subsequent operations don't immediately see bytes
243   // available.
244   ResetEvent(m_event_handles[kBytesAvailableEvent]);
245 
246   IncrementFilePointer(return_info.GetBytes());
247   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
248   if (log) {
249     LLDB_LOGF(log,
250               "%p ConnectionGenericFile::Read()  handle = %p, dst = %p, "
251               "dst_len = %zu) => %zu, error = %s",
252               this, m_file, dst, dst_len, return_info.GetBytes(),
253               return_info.GetError().AsCString());
254   }
255 
256   return return_info.GetBytes();
257 }
258 
259 size_t ConnectionGenericFile::Write(const void *src, size_t src_len,
260                                     lldb::ConnectionStatus &status,
261                                     Status *error_ptr) {
262   ReturnInfo return_info;
263   DWORD bytes_written = 0;
264   BOOL result = 0;
265 
266   if (error_ptr)
267     error_ptr->Clear();
268 
269   if (!IsConnected()) {
270     return_info.Set(0, eConnectionStatusNoConnection, ERROR_INVALID_HANDLE);
271     goto finish;
272   }
273 
274   m_overlapped.hEvent = NULL;
275 
276   // Writes are not interruptible like reads are, so just block until it's
277   // done.
278   result = ::WriteFile(m_file, src, src_len, NULL, &m_overlapped);
279   if (!result && ::GetLastError() != ERROR_IO_PENDING) {
280     return_info.Set(0, eConnectionStatusError, ::GetLastError());
281     goto finish;
282   }
283 
284   if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_written, TRUE)) {
285     return_info.Set(bytes_written, eConnectionStatusError, ::GetLastError());
286     goto finish;
287   }
288 
289   return_info.Set(bytes_written, eConnectionStatusSuccess, 0);
290   goto finish;
291 
292 finish:
293   status = return_info.GetStatus();
294   if (error_ptr)
295     *error_ptr = return_info.GetError();
296 
297   IncrementFilePointer(return_info.GetBytes());
298   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
299   if (log) {
300     LLDB_LOGF(log,
301               "%p ConnectionGenericFile::Write()  handle = %p, src = %p, "
302               "src_len = %zu) => %zu, error = %s",
303               this, m_file, src, src_len, return_info.GetBytes(),
304               return_info.GetError().AsCString());
305   }
306   return return_info.GetBytes();
307 }
308 
309 std::string ConnectionGenericFile::GetURI() { return m_uri; }
310 
311 bool ConnectionGenericFile::InterruptRead() {
312   return ::SetEvent(m_event_handles[kInterruptEvent]);
313 }
314 
315 void ConnectionGenericFile::IncrementFilePointer(DWORD amount) {
316   LARGE_INTEGER old_pos;
317   old_pos.HighPart = m_overlapped.OffsetHigh;
318   old_pos.LowPart = m_overlapped.Offset;
319   old_pos.QuadPart += amount;
320   m_overlapped.Offset = old_pos.LowPart;
321   m_overlapped.OffsetHigh = old_pos.HighPart;
322 }
323