93c1b3caf0
.. and reduce the scope of others. They don't follow llvm coding standards (which say they should be used only when the same effect cannot be achieved with the static keyword), and they set a bad example.
337 lines
12 KiB
C++
337 lines
12 KiB
C++
//===-- PipeWindows.cpp ---------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Host/windows/PipeWindows.h"
|
|
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/Support/Process.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <io.h>
|
|
#include <rpc.h>
|
|
|
|
#include <atomic>
|
|
#include <string>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
static std::atomic<uint32_t> g_pipe_serial(0);
|
|
static constexpr llvm::StringLiteral g_pipe_name_prefix = "\\\\.\\Pipe\\";
|
|
|
|
PipeWindows::PipeWindows()
|
|
: m_read(INVALID_HANDLE_VALUE), m_write(INVALID_HANDLE_VALUE),
|
|
m_read_fd(PipeWindows::kInvalidDescriptor),
|
|
m_write_fd(PipeWindows::kInvalidDescriptor) {
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
}
|
|
|
|
PipeWindows::PipeWindows(pipe_t read, pipe_t write)
|
|
: m_read((HANDLE)read), m_write((HANDLE)write),
|
|
m_read_fd(PipeWindows::kInvalidDescriptor),
|
|
m_write_fd(PipeWindows::kInvalidDescriptor) {
|
|
assert(read != LLDB_INVALID_PIPE || write != LLDB_INVALID_PIPE);
|
|
|
|
// Don't risk in passing file descriptors and getting handles from them by
|
|
// _get_osfhandle since the retrieved handles are highly likely unrecognized
|
|
// in the current process and usually crashes the program. Pass handles
|
|
// instead since the handle can be inherited.
|
|
|
|
if (read != LLDB_INVALID_PIPE) {
|
|
m_read_fd = _open_osfhandle((intptr_t)read, _O_RDONLY);
|
|
// Make sure the fd and native handle are consistent.
|
|
if (m_read_fd < 0)
|
|
m_read = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (write != LLDB_INVALID_PIPE) {
|
|
m_write_fd = _open_osfhandle((intptr_t)write, _O_WRONLY);
|
|
if (m_write_fd < 0)
|
|
m_write = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
}
|
|
|
|
PipeWindows::~PipeWindows() { Close(); }
|
|
|
|
Status PipeWindows::CreateNew(bool child_process_inherit) {
|
|
// Create an anonymous pipe with the specified inheritance.
|
|
SECURITY_ATTRIBUTES sa{sizeof(SECURITY_ATTRIBUTES), 0,
|
|
child_process_inherit ? TRUE : FALSE};
|
|
BOOL result = ::CreatePipe(&m_read, &m_write, &sa, 1024);
|
|
if (result == FALSE)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
m_read_overlapped.hEvent = ::CreateEventA(nullptr, TRUE, FALSE, nullptr);
|
|
|
|
m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY);
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
|
|
return Status();
|
|
}
|
|
|
|
Status PipeWindows::CreateNewNamed(bool child_process_inherit) {
|
|
// Even for anonymous pipes, we open a named pipe. This is because you
|
|
// cannot get overlapped i/o on Windows without using a named pipe. So we
|
|
// synthesize a unique name.
|
|
uint32_t serial = g_pipe_serial.fetch_add(1);
|
|
std::string pipe_name;
|
|
llvm::raw_string_ostream pipe_name_stream(pipe_name);
|
|
pipe_name_stream << "lldb.pipe." << ::GetCurrentProcessId() << "." << serial;
|
|
pipe_name_stream.flush();
|
|
|
|
return CreateNew(pipe_name.c_str(), child_process_inherit);
|
|
}
|
|
|
|
Status PipeWindows::CreateNew(llvm::StringRef name,
|
|
bool child_process_inherit) {
|
|
if (name.empty())
|
|
return Status(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
|
|
|
|
if (CanRead() || CanWrite())
|
|
return Status(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
|
|
|
|
std::string pipe_path = g_pipe_name_prefix.str();
|
|
pipe_path.append(name.str());
|
|
|
|
// Always open for overlapped i/o. We implement blocking manually in Read
|
|
// and Write.
|
|
DWORD read_mode = FILE_FLAG_OVERLAPPED;
|
|
m_read = ::CreateNamedPipeA(
|
|
pipe_path.c_str(), PIPE_ACCESS_INBOUND | read_mode,
|
|
PIPE_TYPE_BYTE | PIPE_WAIT, 1, 1024, 1024, 120 * 1000, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_read)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
|
|
|
|
// Open the write end of the pipe. Note that closing either the read or
|
|
// write end of the pipe could directly close the pipe itself.
|
|
Status result = OpenNamedPipe(name, child_process_inherit, false);
|
|
if (!result.Success()) {
|
|
CloseReadFileDescriptor();
|
|
return result;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
Status PipeWindows::CreateWithUniqueName(llvm::StringRef prefix,
|
|
bool child_process_inherit,
|
|
llvm::SmallVectorImpl<char> &name) {
|
|
llvm::SmallString<128> pipe_name;
|
|
Status error;
|
|
::UUID unique_id;
|
|
RPC_CSTR unique_string;
|
|
RPC_STATUS status = ::UuidCreate(&unique_id);
|
|
if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY)
|
|
status = ::UuidToStringA(&unique_id, &unique_string);
|
|
if (status == RPC_S_OK) {
|
|
pipe_name = prefix;
|
|
pipe_name += "-";
|
|
pipe_name += reinterpret_cast<char *>(unique_string);
|
|
::RpcStringFreeA(&unique_string);
|
|
error = CreateNew(pipe_name, child_process_inherit);
|
|
} else {
|
|
error.SetError(status, eErrorTypeWin32);
|
|
}
|
|
if (error.Success())
|
|
name = pipe_name;
|
|
return error;
|
|
}
|
|
|
|
Status PipeWindows::OpenAsReader(llvm::StringRef name,
|
|
bool child_process_inherit) {
|
|
if (CanRead())
|
|
return Status(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
|
|
|
|
return OpenNamedPipe(name, child_process_inherit, true);
|
|
}
|
|
|
|
Status
|
|
PipeWindows::OpenAsWriterWithTimeout(llvm::StringRef name,
|
|
bool child_process_inherit,
|
|
const std::chrono::microseconds &timeout) {
|
|
if (CanWrite())
|
|
return Status(ERROR_ALREADY_EXISTS, eErrorTypeWin32);
|
|
|
|
return OpenNamedPipe(name, child_process_inherit, false);
|
|
}
|
|
|
|
Status PipeWindows::OpenNamedPipe(llvm::StringRef name,
|
|
bool child_process_inherit, bool is_read) {
|
|
if (name.empty())
|
|
return Status(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
|
|
|
|
assert(is_read ? !CanRead() : !CanWrite());
|
|
|
|
SECURITY_ATTRIBUTES attributes = {};
|
|
attributes.bInheritHandle = child_process_inherit;
|
|
|
|
std::string pipe_path = g_pipe_name_prefix.str();
|
|
pipe_path.append(name.str());
|
|
|
|
if (is_read) {
|
|
m_read = ::CreateFileA(pipe_path.c_str(), GENERIC_READ, 0, &attributes,
|
|
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_read)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
m_read_fd = _open_osfhandle((intptr_t)m_read, _O_RDONLY);
|
|
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
m_read_overlapped.hEvent = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
|
|
} else {
|
|
m_write = ::CreateFileA(pipe_path.c_str(), GENERIC_WRITE, 0, &attributes,
|
|
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
|
|
if (INVALID_HANDLE_VALUE == m_write)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
m_write_fd = _open_osfhandle((intptr_t)m_write, _O_WRONLY);
|
|
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
}
|
|
|
|
return Status();
|
|
}
|
|
|
|
int PipeWindows::GetReadFileDescriptor() const { return m_read_fd; }
|
|
|
|
int PipeWindows::GetWriteFileDescriptor() const { return m_write_fd; }
|
|
|
|
int PipeWindows::ReleaseReadFileDescriptor() {
|
|
if (!CanRead())
|
|
return PipeWindows::kInvalidDescriptor;
|
|
int result = m_read_fd;
|
|
m_read_fd = PipeWindows::kInvalidDescriptor;
|
|
if (m_read_overlapped.hEvent)
|
|
::CloseHandle(m_read_overlapped.hEvent);
|
|
m_read = INVALID_HANDLE_VALUE;
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
return result;
|
|
}
|
|
|
|
int PipeWindows::ReleaseWriteFileDescriptor() {
|
|
if (!CanWrite())
|
|
return PipeWindows::kInvalidDescriptor;
|
|
int result = m_write_fd;
|
|
m_write_fd = PipeWindows::kInvalidDescriptor;
|
|
m_write = INVALID_HANDLE_VALUE;
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
return result;
|
|
}
|
|
|
|
void PipeWindows::CloseReadFileDescriptor() {
|
|
if (!CanRead())
|
|
return;
|
|
|
|
if (m_read_overlapped.hEvent)
|
|
::CloseHandle(m_read_overlapped.hEvent);
|
|
|
|
_close(m_read_fd);
|
|
m_read = INVALID_HANDLE_VALUE;
|
|
m_read_fd = PipeWindows::kInvalidDescriptor;
|
|
ZeroMemory(&m_read_overlapped, sizeof(m_read_overlapped));
|
|
}
|
|
|
|
void PipeWindows::CloseWriteFileDescriptor() {
|
|
if (!CanWrite())
|
|
return;
|
|
|
|
_close(m_write_fd);
|
|
m_write = INVALID_HANDLE_VALUE;
|
|
m_write_fd = PipeWindows::kInvalidDescriptor;
|
|
ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
|
|
}
|
|
|
|
void PipeWindows::Close() {
|
|
CloseReadFileDescriptor();
|
|
CloseWriteFileDescriptor();
|
|
}
|
|
|
|
Status PipeWindows::Delete(llvm::StringRef name) { return Status(); }
|
|
|
|
bool PipeWindows::CanRead() const { return (m_read != INVALID_HANDLE_VALUE); }
|
|
|
|
bool PipeWindows::CanWrite() const { return (m_write != INVALID_HANDLE_VALUE); }
|
|
|
|
HANDLE
|
|
PipeWindows::GetReadNativeHandle() { return m_read; }
|
|
|
|
HANDLE
|
|
PipeWindows::GetWriteNativeHandle() { return m_write; }
|
|
|
|
Status PipeWindows::ReadWithTimeout(void *buf, size_t size,
|
|
const std::chrono::microseconds &duration,
|
|
size_t &bytes_read) {
|
|
if (!CanRead())
|
|
return Status(ERROR_INVALID_HANDLE, eErrorTypeWin32);
|
|
|
|
bytes_read = 0;
|
|
DWORD sys_bytes_read = size;
|
|
BOOL result = ::ReadFile(m_read, buf, sys_bytes_read, &sys_bytes_read,
|
|
&m_read_overlapped);
|
|
if (!result && GetLastError() != ERROR_IO_PENDING)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
DWORD timeout = (duration == std::chrono::microseconds::zero())
|
|
? INFINITE
|
|
: duration.count() * 1000;
|
|
DWORD wait_result = ::WaitForSingleObject(m_read_overlapped.hEvent, timeout);
|
|
if (wait_result != WAIT_OBJECT_0) {
|
|
// The operation probably failed. However, if it timed out, we need to
|
|
// cancel the I/O. Between the time we returned from WaitForSingleObject
|
|
// and the time we call CancelIoEx, the operation may complete. If that
|
|
// hapens, CancelIoEx will fail and return ERROR_NOT_FOUND. If that
|
|
// happens, the original operation should be considered to have been
|
|
// successful.
|
|
bool failed = true;
|
|
DWORD failure_error = ::GetLastError();
|
|
if (wait_result == WAIT_TIMEOUT) {
|
|
BOOL cancel_result = CancelIoEx(m_read, &m_read_overlapped);
|
|
if (!cancel_result && GetLastError() == ERROR_NOT_FOUND)
|
|
failed = false;
|
|
}
|
|
if (failed)
|
|
return Status(failure_error, eErrorTypeWin32);
|
|
}
|
|
|
|
// Now we call GetOverlappedResult setting bWait to false, since we've
|
|
// already waited as long as we're willing to.
|
|
if (!GetOverlappedResult(m_read, &m_read_overlapped, &sys_bytes_read, FALSE))
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
bytes_read = sys_bytes_read;
|
|
return Status();
|
|
}
|
|
|
|
Status PipeWindows::Write(const void *buf, size_t num_bytes,
|
|
size_t &bytes_written) {
|
|
if (!CanWrite())
|
|
return Status(ERROR_INVALID_HANDLE, eErrorTypeWin32);
|
|
|
|
DWORD sys_bytes_written = 0;
|
|
BOOL write_result = ::WriteFile(m_write, buf, num_bytes, &sys_bytes_written,
|
|
&m_write_overlapped);
|
|
if (!write_result && GetLastError() != ERROR_IO_PENDING)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
|
|
BOOL result = GetOverlappedResult(m_write, &m_write_overlapped,
|
|
&sys_bytes_written, TRUE);
|
|
if (!result)
|
|
return Status(::GetLastError(), eErrorTypeWin32);
|
|
return Status();
|
|
}
|