1 //===-- PipeWindows.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/PipeWindows.h" 10 11 #include "llvm/ADT/SmallString.h" 12 #include "llvm/Support/Process.h" 13 #include "llvm/Support/raw_ostream.h" 14 15 #include <fcntl.h> 16 #include <io.h> 17 #include <rpc.h> 18 19 #include <atomic> 20 #include <string> 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 static std::atomic<uint32_t> g_pipe_serial(0); 26 static constexpr llvm::StringLiteral g_pipe_name_prefix = "\\\\.\\Pipe\\"; 27 28 PipeWindows::PipeWindows() 29 : m_read(INVALID_HANDLE_VALUE), m_write(INVALID_HANDLE_VALUE), 30 m_read_fd(PipeWindows::kInvalidDescriptor), 31 m_write_fd(PipeWindows::kInvalidDescriptor) { 32 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 33 ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped)); 34 } 35 36 PipeWindows::PipeWindows(pipe_t read, pipe_t write) 37 : m_read((HANDLE)read), m_write((HANDLE)write), 38 m_read_fd(PipeWindows::kInvalidDescriptor), 39 m_write_fd(PipeWindows::kInvalidDescriptor) { 40 assert(read != LLDB_INVALID_PIPE || write != LLDB_INVALID_PIPE); 41 42 // Don't risk in passing file descriptors and getting handles from them by 43 // _get_osfhandle since the retrieved handles are highly likely unrecognized 44 // in the current process and usually crashes the program. Pass handles 45 // instead since the handle can be inherited. 46 47 if (read != LLDB_INVALID_PIPE) { 48 m_read_fd = _open_osfhandle((intptr_t)read, _O_RDONLY); 49 // Make sure the fd and native handle are consistent. 50 if (m_read_fd < 0) 51 m_read = INVALID_HANDLE_VALUE; 52 } 53 54 if (write != LLDB_INVALID_PIPE) { 55 m_write_fd = _open_osfhandle((intptr_t)write, _O_WRONLY); 56 if (m_write_fd < 0) 57 m_write = INVALID_HANDLE_VALUE; 58 } 59 60 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 61 m_read_overlapped.hEvent = ::CreateEventA(nullptr, TRUE, FALSE, nullptr); 62 63 ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped)); 64 m_write_overlapped.hEvent = ::CreateEventA(nullptr, TRUE, FALSE, nullptr); 65 } 66 67 PipeWindows::~PipeWindows() { Close(); } 68 69 Status PipeWindows::CreateNew(bool child_process_inherit) { 70 // Even for anonymous pipes, we open a named pipe. This is because you 71 // cannot get overlapped i/o on Windows without using a named pipe. So we 72 // synthesize a unique name. 73 uint32_t serial = g_pipe_serial.fetch_add(1); 74 std::string pipe_name = llvm::formatv( 75 "lldb.pipe.{0}.{1}.{2}", GetCurrentProcessId(), &g_pipe_serial, serial); 76 77 return CreateNew(pipe_name.c_str(), child_process_inherit); 78 } 79 80 Status PipeWindows::CreateNew(llvm::StringRef name, 81 bool child_process_inherit) { 82 if (name.empty()) 83 return Status(ERROR_INVALID_PARAMETER, eErrorTypeWin32); 84 85 if (CanRead() || CanWrite()) 86 return Status(ERROR_ALREADY_EXISTS, eErrorTypeWin32); 87 88 std::string pipe_path = g_pipe_name_prefix.str(); 89 pipe_path.append(name.str()); 90 91 SECURITY_ATTRIBUTES sa{sizeof(SECURITY_ATTRIBUTES), 0, 92 child_process_inherit ? TRUE : FALSE}; 93 94 // Always open for overlapped i/o. We implement blocking manually in Read 95 // and Write. 96 DWORD read_mode = FILE_FLAG_OVERLAPPED; 97 m_read = 98 ::CreateNamedPipeA(pipe_path.c_str(), PIPE_ACCESS_INBOUND | read_mode, 99 PIPE_TYPE_BYTE | PIPE_WAIT, /*nMaxInstances=*/1, 100 /*nOutBufferSize=*/1024, 101 /*nInBufferSize=*/1024, 102 /*nDefaultTimeOut=*/0, &sa); 103 if (INVALID_HANDLE_VALUE == m_read) 104 return Status(::GetLastError(), eErrorTypeWin32); 105 m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY); 106 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 107 m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr); 108 109 // Open the write end of the pipe. Note that closing either the read or 110 // write end of the pipe could directly close the pipe itself. 111 Status result = OpenNamedPipe(name, child_process_inherit, false); 112 if (!result.Success()) { 113 CloseReadFileDescriptor(); 114 return result; 115 } 116 117 return result; 118 } 119 120 Status PipeWindows::CreateWithUniqueName(llvm::StringRef prefix, 121 bool child_process_inherit, 122 llvm::SmallVectorImpl<char> &name) { 123 llvm::SmallString<128> pipe_name; 124 Status error; 125 ::UUID unique_id; 126 RPC_CSTR unique_string; 127 RPC_STATUS status = ::UuidCreate(&unique_id); 128 if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY) 129 status = ::UuidToStringA(&unique_id, &unique_string); 130 if (status == RPC_S_OK) { 131 pipe_name = prefix; 132 pipe_name += "-"; 133 pipe_name += reinterpret_cast<char *>(unique_string); 134 ::RpcStringFreeA(&unique_string); 135 error = CreateNew(pipe_name, child_process_inherit); 136 } else { 137 error = Status(status, eErrorTypeWin32); 138 } 139 if (error.Success()) 140 name = pipe_name; 141 return error; 142 } 143 144 Status PipeWindows::OpenAsReader(llvm::StringRef name, 145 bool child_process_inherit) { 146 if (CanRead()) 147 return Status(); // Note the name is ignored. 148 149 return OpenNamedPipe(name, child_process_inherit, true); 150 } 151 152 Status 153 PipeWindows::OpenAsWriterWithTimeout(llvm::StringRef name, 154 bool child_process_inherit, 155 const std::chrono::microseconds &timeout) { 156 if (CanWrite()) 157 return Status(); // Note the name is ignored. 158 159 return OpenNamedPipe(name, child_process_inherit, false); 160 } 161 162 Status PipeWindows::OpenNamedPipe(llvm::StringRef name, 163 bool child_process_inherit, bool is_read) { 164 if (name.empty()) 165 return Status(ERROR_INVALID_PARAMETER, eErrorTypeWin32); 166 167 assert(is_read ? !CanRead() : !CanWrite()); 168 169 SECURITY_ATTRIBUTES attributes{sizeof(SECURITY_ATTRIBUTES), 0, 170 child_process_inherit ? TRUE : FALSE}; 171 172 std::string pipe_path = g_pipe_name_prefix.str(); 173 pipe_path.append(name.str()); 174 175 if (is_read) { 176 m_read = ::CreateFileA(pipe_path.c_str(), GENERIC_READ, 0, &attributes, 177 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); 178 if (INVALID_HANDLE_VALUE == m_read) 179 return Status(::GetLastError(), eErrorTypeWin32); 180 181 m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY); 182 183 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 184 m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr); 185 } else { 186 m_write = ::CreateFileA(pipe_path.c_str(), GENERIC_WRITE, 0, &attributes, 187 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); 188 if (INVALID_HANDLE_VALUE == m_write) 189 return Status(::GetLastError(), eErrorTypeWin32); 190 191 m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY); 192 193 ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped)); 194 m_write_overlapped.hEvent = ::CreateEventA(nullptr, TRUE, FALSE, nullptr); 195 } 196 197 return Status(); 198 } 199 200 int PipeWindows::GetReadFileDescriptor() const { return m_read_fd; } 201 202 int PipeWindows::GetWriteFileDescriptor() const { return m_write_fd; } 203 204 int PipeWindows::ReleaseReadFileDescriptor() { 205 if (!CanRead()) 206 return PipeWindows::kInvalidDescriptor; 207 int result = m_read_fd; 208 m_read_fd = PipeWindows::kInvalidDescriptor; 209 if (m_read_overlapped.hEvent) 210 ::CloseHandle(m_read_overlapped.hEvent); 211 m_read = INVALID_HANDLE_VALUE; 212 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 213 return result; 214 } 215 216 int PipeWindows::ReleaseWriteFileDescriptor() { 217 if (!CanWrite()) 218 return PipeWindows::kInvalidDescriptor; 219 int result = m_write_fd; 220 m_write_fd = PipeWindows::kInvalidDescriptor; 221 if (m_write_overlapped.hEvent) 222 ::CloseHandle(m_write_overlapped.hEvent); 223 m_write = INVALID_HANDLE_VALUE; 224 ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped)); 225 return result; 226 } 227 228 void PipeWindows::CloseReadFileDescriptor() { 229 if (!CanRead()) 230 return; 231 232 if (m_read_overlapped.hEvent) 233 ::CloseHandle(m_read_overlapped.hEvent); 234 235 _close(m_read_fd); 236 m_read = INVALID_HANDLE_VALUE; 237 m_read_fd = PipeWindows::kInvalidDescriptor; 238 ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped)); 239 } 240 241 void PipeWindows::CloseWriteFileDescriptor() { 242 if (!CanWrite()) 243 return; 244 245 if (m_write_overlapped.hEvent) 246 ::CloseHandle(m_write_overlapped.hEvent); 247 248 _close(m_write_fd); 249 m_write = INVALID_HANDLE_VALUE; 250 m_write_fd = PipeWindows::kInvalidDescriptor; 251 ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped)); 252 } 253 254 void PipeWindows::Close() { 255 CloseReadFileDescriptor(); 256 CloseWriteFileDescriptor(); 257 } 258 259 Status PipeWindows::Delete(llvm::StringRef name) { return Status(); } 260 261 bool PipeWindows::CanRead() const { return (m_read != INVALID_HANDLE_VALUE); } 262 263 bool PipeWindows::CanWrite() const { return (m_write != INVALID_HANDLE_VALUE); } 264 265 HANDLE 266 PipeWindows::GetReadNativeHandle() { return m_read; } 267 268 HANDLE 269 PipeWindows::GetWriteNativeHandle() { return m_write; } 270 271 Status PipeWindows::ReadWithTimeout(void *buf, size_t size, 272 const std::chrono::microseconds &duration, 273 size_t &bytes_read) { 274 if (!CanRead()) 275 return Status(ERROR_INVALID_HANDLE, eErrorTypeWin32); 276 277 bytes_read = 0; 278 DWORD sys_bytes_read = 0; 279 BOOL result = 280 ::ReadFile(m_read, buf, size, &sys_bytes_read, &m_read_overlapped); 281 if (result) { 282 bytes_read = sys_bytes_read; 283 return Status(); 284 } 285 286 DWORD failure_error = ::GetLastError(); 287 if (failure_error != ERROR_IO_PENDING) 288 return Status(failure_error, eErrorTypeWin32); 289 290 DWORD timeout = (duration == std::chrono::microseconds::zero()) 291 ? INFINITE 292 : duration.count() / 1000; 293 DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout); 294 if (wait_result != WAIT_OBJECT_0) { 295 // The operation probably failed. However, if it timed out, we need to 296 // cancel the I/O. Between the time we returned from WaitForSingleObject 297 // and the time we call CancelIoEx, the operation may complete. If that 298 // hapens, CancelIoEx will fail and return ERROR_NOT_FOUND. If that 299 // happens, the original operation should be considered to have been 300 // successful. 301 bool failed = true; 302 failure_error = ::GetLastError(); 303 if (wait_result == WAIT_TIMEOUT) { 304 BOOL cancel_result = ::CancelIoEx(m_read, &m_read_overlapped); 305 if (!cancel_result && ::GetLastError() == ERROR_NOT_FOUND) 306 failed = false; 307 } 308 if (failed) 309 return Status(failure_error, eErrorTypeWin32); 310 } 311 312 // Now we call GetOverlappedResult setting bWait to false, since we've 313 // already waited as long as we're willing to. 314 if (!::GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, 315 FALSE)) 316 return Status(::GetLastError(), eErrorTypeWin32); 317 318 bytes_read = sys_bytes_read; 319 return Status(); 320 } 321 322 Status PipeWindows::WriteWithTimeout(const void *buf, size_t size, 323 const std::chrono::microseconds &duration, 324 size_t &bytes_written) { 325 if (!CanWrite()) 326 return Status(ERROR_INVALID_HANDLE, eErrorTypeWin32); 327 328 bytes_written = 0; 329 DWORD sys_bytes_write = 0; 330 BOOL result = 331 ::WriteFile(m_write, buf, size, &sys_bytes_write, &m_write_overlapped); 332 if (result) { 333 bytes_written = sys_bytes_write; 334 return Status(); 335 } 336 337 DWORD failure_error = ::GetLastError(); 338 if (failure_error != ERROR_IO_PENDING) 339 return Status(failure_error, eErrorTypeWin32); 340 341 DWORD timeout = (duration == std::chrono::microseconds::zero()) 342 ? INFINITE 343 : duration.count() / 1000; 344 DWORD wait_result = ::WaitForSingleObject(m_write_overlapped.hEvent, timeout); 345 if (wait_result != WAIT_OBJECT_0) { 346 // The operation probably failed. However, if it timed out, we need to 347 // cancel the I/O. Between the time we returned from WaitForSingleObject 348 // and the time we call CancelIoEx, the operation may complete. If that 349 // hapens, CancelIoEx will fail and return ERROR_NOT_FOUND. If that 350 // happens, the original operation should be considered to have been 351 // successful. 352 bool failed = true; 353 failure_error = ::GetLastError(); 354 if (wait_result == WAIT_TIMEOUT) { 355 BOOL cancel_result = ::CancelIoEx(m_write, &m_write_overlapped); 356 if (!cancel_result && ::GetLastError() == ERROR_NOT_FOUND) 357 failed = false; 358 } 359 if (failed) 360 return Status(failure_error, eErrorTypeWin32); 361 } 362 363 // Now we call GetOverlappedResult setting bWait to false, since we've 364 // already waited as long as we're willing to. 365 if (!::GetOverlappedResult(m_write, &m_write_overlapped, &sys_bytes_write, 366 FALSE)) 367 return Status(::GetLastError(), eErrorTypeWin32); 368 369 bytes_written = sys_bytes_write; 370 return Status(); 371 } 372