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/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:
Set(size_t bytes,ConnectionStatus status,DWORD error_code)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
Set(size_t bytes,ConnectionStatus status,llvm::StringRef error_msg)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
GetBytes() const41 size_t GetBytes() const { return m_bytes; }
GetStatus() const42 ConnectionStatus GetStatus() const { return m_status; }
GetError() const43 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
ConnectionGenericFile()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
ConnectionGenericFile(lldb::file_t file,bool owns_file)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
~ConnectionGenericFile()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
InitializeEventHandles()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
IsConnected() const87 bool ConnectionGenericFile::IsConnected() const {
88 return m_file && (m_file != INVALID_HANDLE_VALUE);
89 }
90
Connect(llvm::StringRef path,Status * error_ptr)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 = path.str();
131 return eConnectionStatusSuccess;
132 }
133
Disconnect(Status * error_ptr)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
Read(void * dst,size_t dst_len,const Timeout<std::micro> & timeout,lldb::ConnectionStatus & status,Status * error_ptr)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 LLDB_LOGF(log,
249 "%p ConnectionGenericFile::Read() handle = %p, dst = %p, "
250 "dst_len = %zu) => %zu, error = %s",
251 static_cast<void *>(this), m_file, dst, dst_len,
252 return_info.GetBytes(), return_info.GetError().AsCString());
253
254 return return_info.GetBytes();
255 }
256
Write(const void * src,size_t src_len,lldb::ConnectionStatus & status,Status * error_ptr)257 size_t ConnectionGenericFile::Write(const void *src, size_t src_len,
258 lldb::ConnectionStatus &status,
259 Status *error_ptr) {
260 ReturnInfo return_info;
261 DWORD bytes_written = 0;
262 BOOL result = 0;
263
264 if (error_ptr)
265 error_ptr->Clear();
266
267 if (!IsConnected()) {
268 return_info.Set(0, eConnectionStatusNoConnection, ERROR_INVALID_HANDLE);
269 goto finish;
270 }
271
272 m_overlapped.hEvent = NULL;
273
274 // Writes are not interruptible like reads are, so just block until it's
275 // done.
276 result = ::WriteFile(m_file, src, src_len, NULL, &m_overlapped);
277 if (!result && ::GetLastError() != ERROR_IO_PENDING) {
278 return_info.Set(0, eConnectionStatusError, ::GetLastError());
279 goto finish;
280 }
281
282 if (!::GetOverlappedResult(m_file, &m_overlapped, &bytes_written, TRUE)) {
283 return_info.Set(bytes_written, eConnectionStatusError, ::GetLastError());
284 goto finish;
285 }
286
287 return_info.Set(bytes_written, eConnectionStatusSuccess, 0);
288 goto finish;
289
290 finish:
291 status = return_info.GetStatus();
292 if (error_ptr)
293 *error_ptr = return_info.GetError();
294
295 IncrementFilePointer(return_info.GetBytes());
296 Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
297 LLDB_LOGF(log,
298 "%p ConnectionGenericFile::Write() handle = %p, src = %p, "
299 "src_len = %zu) => %zu, error = %s",
300 static_cast<void *>(this), m_file, src, src_len,
301 return_info.GetBytes(), return_info.GetError().AsCString());
302 return return_info.GetBytes();
303 }
304
GetURI()305 std::string ConnectionGenericFile::GetURI() { return m_uri; }
306
InterruptRead()307 bool ConnectionGenericFile::InterruptRead() {
308 return ::SetEvent(m_event_handles[kInterruptEvent]);
309 }
310
IncrementFilePointer(DWORD amount)311 void ConnectionGenericFile::IncrementFilePointer(DWORD amount) {
312 LARGE_INTEGER old_pos;
313 old_pos.HighPart = m_overlapped.OffsetHigh;
314 old_pos.LowPart = m_overlapped.Offset;
315 old_pos.QuadPart += amount;
316 m_overlapped.Offset = old_pos.LowPart;
317 m_overlapped.OffsetHigh = old_pos.HighPart;
318 }
319