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