[lldb-server] Add unnamed pipe support to PipeWindows

[asmith]

Summary

This adds unnamed pipe support in PipeWindows to support communication between a debug server and child process.
Modify PipeWindows::CreateNew to support the creation of an unnamed pipe.
Rename the previous method that created a named pipe to PipeWindows::CreateNewNamed.

[labath]

source/Host/windows/PipeWindows.cpp

37

This would be better as llvm::StringLiteral (or just a char array) to avoid global constructors. Also, static in an anonymous namespace is overkill (anon namespace implies static linkage).

72

inherited

123–124

I find it strange reading about "servers" in a low-level utility class that seemingly has nothing to do with serving. I think this will confuse future readers as they will not look at this in the context of this patch. Could you rephrase this?

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1075

What do you think about adding GetWriteNativeHandle to the generic Pipe interface? In posix the file descriptor _is_ the native handle, so PipePosix could just return the fd, but it would allow you to write this bit of code generically without ifdefs (well, maybe except the AppendCloseFileAction below). Similarly, we could have a generic Pipe factory function(*) which takes the handles as input, which would allow you to implement the lldb-server side of things without ifdefs.

(*) I think a factory function (Pipe::FromNativeHandles?) would be better than a constructor to avoid ambiguities between descriptors and handles.

[zturner]

source/Host/windows/PipeWindows.cpp

38–63

Perhaps we should use inline member initialization for these fields in the class definition.

63–64

Is it valid for a creator of a PipeWindows to pass in invalid handles when using this constructor? If not, we should assert. Certainly it doesn't make sense if *both* of the handles are invalid, so we can definitely at least assert that case.

74

Is the ternary necessary here? can't we just assign it?

76–81

With inline member initialization, this becomes:

PipeWindows::PipeWindows(HANDLE read, HANDLE write)
  : m_read(read), m_write(write) {
  if (read != INVALID_HANDLE_VALUE)
    m_read_fd = _open_osfhandle((intptr_t)read, _O_RDONLY);
  if (write != INVALID_HANDLE_VALUE)
    m_write_fd = _open_osfhandle((intptr_t)write, _O_RDONLY);
}

123–124

I actually think the previous comment was fine?

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1075

That's one possibility, but at the very least we should at least move the CreateNew and logging out of the ifdef.

tools/lldb-server/lldb-gdbserver.cpp

220–224

One way to get rid of all these ifdefs is to to define a type called lldb::pipe_t and change Pipe::kInvalidDescriptor to be lldb::pipe_t kInvalidPipe (for example, see definition of lldb::thread_t in lldb-types.h). Then you could change the constructor to be Pipe::Pipe(lldb::pipe_t read, lldb::pipe_t write) and this function could be written as:

Status writeSocketIdToPipe(lldb::pipe_t pipe) {
  Pipe port_pipe(Pipe::kInvalidPipe, pipe);
  return writeSocketIdToPipe(port_pipe, socket_id);
}

At that point though, maybe we don't even need a separate function for this anymore.

331–332

This needs to change to unnamed_pipe_fd_or_handle != Pipe::kInvalidPipe

384

lldb::pipe_t unnamed_pipe_fd_or_handle;

[Hui]

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

1052

My first attempt was to enable windows specific along with apple's since named pipe is already supported. Seemed there was some problem for client pipe to open a server pipe on the same machine. This might not be the scope of this discussion.

1075

Based on the lldb::pipe_t, using one of the introduced overloads could just put the windows specific all the way into the existing non-apple implementation. AppendCloseFileAction seemed yet impact anything.

lldb::pipe_t GetReadPipe() const { return lldb::pipe_t(m_read); }
lldb::pipe_t GetWritePipe() const { return lldb::pipe_t(m_write); }

[asmith]

Add lldb::pipe_t type

[zturner]

This looks much nicer with the pipe_t type.

source/Host/posix/PipePosix.cpp

70

I don't think you need the cast, since the type is already int. (Some compilers will warn if you cast something to its own type).

[labath]

Looks very nice. Thanks.

include/lldb/Host/windows/PipeWindows.h

52

missing override (that will likely be flagged as a warning by clang)?

[labath]

include/lldb/Host/windows/PipeWindows.h

71–74

Are these still necessary?

[Hui]

In D56234#1352371, @labath wrote:

Looks very nice. Thanks.

There is a similar type file_t widely used in llvm.

include/lldb/Host/PipeBase.h

public:
   Status OpenAsWriter(llvm::StringRef name, bool child_process_inherit);
   virtual Status
   OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
                           const std::chrono::microseconds &timeout) = 0;
 
   virtual bool CanRead() const = 0;
   virtual bool CanWrite() const = 0;
 
+  virtual lldb::pipe_t GetReadPipe() const = 0;
+  virtual lldb::pipe_t GetWritePipe() const = 0;
+
   virtual int GetReadFileDescriptor() const = 0;
   virtual int GetWriteFileDescriptor() const = 0;
   virtual int ReleaseReadFileDescriptor() = 0;
   virtual int ReleaseWriteFileDescriptor() = 0;
   virtual void CloseReadFileDescriptor() = 0;
   virtual void CloseWriteFileDescriptor() = 0;
 
   // Close both descriptors

include/lldb/Host/posix/PipePosix.h

 ///
 /// A class that abstracts the LLDB core from host pipe functionality.
 //----------------------------------------------------------------------
 class PipePosix : public PipeBase {
 public:
   static int kInvalidDescriptor;
 
   PipePosix();
-  PipePosix(int read_fd, int write_fd);
+  PipePosix(lldb::pipe_t read, lldb::pipe_t write);
   PipePosix(const PipePosix &) = delete;
   PipePosix(PipePosix &&pipe_posix);
   PipePosix &operator=(const PipePosix &) = delete;
   PipePosix &operator=(PipePosix &&pipe_posix);
 
   ~PipePosix() override;
 
   Status CreateNew(bool child_process_inherit) override;
   Status CreateNew(llvm::StringRef name, bool child_process_inherit) override;
   Status CreateWithUniqueName(llvm::StringRef prefix,
                               bool child_process_inherit,
                               llvm::SmallVectorImpl<char> &name) override;
   Status OpenAsReader(llvm::StringRef name,
                       bool child_process_inherit) override;
   Status
   OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
                           const std::chrono::microseconds &timeout) override;
 
   bool CanRead() const override;
   bool CanWrite() const override;
 
+  lldb::pipe_t GetReadPipe() const override {
+    return lldb::pipe_t(GetReadFileDescriptor());
+  }
+  lldb::pipe_t GetWritePipe() const override {
+    return lldb::pipe_t(GetWriteFileDescriptor());
+  }
+
   int GetReadFileDescriptor() const override;
   int GetWriteFileDescriptor() const override;
   int ReleaseReadFileDescriptor() override;
   int ReleaseWriteFileDescriptor() override;
   void CloseReadFileDescriptor() override;
   void CloseWriteFileDescriptor() override;
 
   // Close both descriptors

include/lldb/Host/windows/PipeWindows.h

 /// @class Pipe PipeWindows.h "lldb/Host/windows/PipeWindows.h"
 /// A windows-based implementation of Pipe, a class that abtracts
 ///        unix style pipes.
 ///
 /// A class that abstracts the LLDB core from host pipe functionality.
 //----------------------------------------------------------------------
 class PipeWindows : public PipeBase {
 public:
+  static const int kInvalidDescriptor = -1;
+
+public:
   PipeWindows();
+  PipeWindows(lldb::pipe_t read, lldb::pipe_t write);
   ~PipeWindows() override;
 
+  // Create an unnamed pipe.
   Status CreateNew(bool child_process_inherit) override;
+
+  // Create a named pipe.
+  Status CreateNewNamed(bool child_process_inherit);
   Status CreateNew(llvm::StringRef name, bool child_process_inherit) override;
   Status CreateWithUniqueName(llvm::StringRef prefix,
                               bool child_process_inherit,
                               llvm::SmallVectorImpl<char> &name) override;
   Status OpenAsReader(llvm::StringRef name,
                       bool child_process_inherit) override;
   Status
   OpenAsWriterWithTimeout(llvm::StringRef name, bool child_process_inherit,
                           const std::chrono::microseconds &timeout) override;
 
   bool CanRead() const override;
   bool CanWrite() const override;
 
+  lldb::pipe_t GetReadPipe() const { return lldb::pipe_t(m_read); }
+  lldb::pipe_t GetWritePipe() const { return lldb::pipe_t(m_write); }
+
   int GetReadFileDescriptor() const override;
   int GetWriteFileDescriptor() const override;
   int ReleaseReadFileDescriptor() override;
   int ReleaseWriteFileDescriptor() override;
   void CloseReadFileDescriptor() override;
   void CloseWriteFileDescriptor() override;
 
   void Close() override;
 
   Status Delete(llvm::StringRef name) override;
 
   Status Write(const void *buf, size_t size, size_t &bytes_written) override;
   Status ReadWithTimeout(void *buf, size_t size,
                          const std::chrono::microseconds &timeout,
                          size_t &bytes_read) override;
 
   // PipeWindows specific methods.  These allow access to the underlying OS
   // handle.
   HANDLE GetReadNativeHandle();
   HANDLE GetWriteNativeHandle();
 
 private:
   Status OpenNamedPipe(llvm::StringRef name, bool child_process_inherit,
                        bool is_read);
 
   HANDLE m_read;
   HANDLE m_write;
 

include/lldb/lldb-types.h

 typedef void *rwlock_t;
 typedef void *process_t;             // Process type is HANDLE
 typedef void *thread_t;              // Host thread type
 typedef void *file_t;                // Host file type
 typedef unsigned int __w64 socket_t; // Host socket type
 typedef void *thread_arg_t;                       // Host thread argument type
 typedef unsigned thread_result_t;                 // Host thread result type
 typedef thread_result_t (*thread_func_t)(void *); // Host thread function type
-}
+typedef void *pipe_t;                             // Host pipe type is HANDLE
+} // namespace lldb
 
 #else
 
 #include <pthread.h>
 
 namespace lldb {
 //----------------------------------------------------------------------
 // MacOSX Types
 //----------------------------------------------------------------------
 typedef pthread_rwlock_t rwlock_t;
 typedef uint64_t process_t; // Process type is just a pid.
 typedef pthread_t thread_t; // Host thread type
 typedef int file_t;         // Host file type
 typedef int socket_t;       // Host socket type
 typedef void *thread_arg_t;             // Host thread argument type
 typedef void *thread_result_t;          // Host thread result type
 typedef void *(*thread_func_t)(void *); // Host thread function type
+typedef int pipe_t;                     // Host pipe type
 } // namespace lldb
 
 #endif
 
 namespace lldb {
 typedef void (*LogOutputCallback)(const char *, void *baton);
 typedef bool (*CommandOverrideCallback)(void *baton, const char **argv);
 typedef bool (*CommandOverrideCallbackWithResult)(
     void *baton, const char **argv, lldb_private::CommandReturnObject &result);
 typedef bool (*ExpressionCancelCallback)(ExpressionEvaluationPhase phase,
                                          void *baton);
-}
+} // namespace lldb
 
 #define LLDB_INVALID_PROCESS ((lldb::process_t)-1)
 #define LLDB_INVALID_HOST_THREAD ((lldb::thread_t)NULL)
+#define LLDB_INVALID_PIPE ((lldb::pipe_t)-1)
 
 namespace lldb {
 typedef uint64_t addr_t;
 typedef uint64_t user_id_t;
 typedef uint64_t pid_t;
 typedef uint64_t tid_t;
 typedef uint64_t offset_t;
 typedef int32_t break_id_t;
 typedef int32_t watch_id_t;
 typedef void *opaque_compiler_type_t;
 typedef uint64_t queue_id_t;
-}
+} // namespace lldb
 
 #endif // LLDB_lldb_types_h_

source/Host/posix/PipePosix.cpp

if (flags == -1)
     return false;
   return (::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == 0);
 }
 #endif
 
 std::chrono::time_point<std::chrono::steady_clock> Now() {
   return std::chrono::steady_clock::now();
 }
-}
+} // namespace
 
 PipePosix::PipePosix()
     : m_fds{PipePosix::kInvalidDescriptor, PipePosix::kInvalidDescriptor} {}
 
-PipePosix::PipePosix(int read_fd, int write_fd) : m_fds{read_fd, write_fd} {}
+PipePosix::PipePosix(lldb::pipe_t read, lldb::pipe_t write)
+    : m_fds{read, write} {}
 
 PipePosix::PipePosix(PipePosix &&pipe_posix)
     : PipeBase{std::move(pipe_posix)},
       m_fds{pipe_posix.ReleaseReadFileDescriptor(),
             pipe_posix.ReleaseWriteFileDescriptor()} {}
 
 PipePosix &PipePosix::operator=(PipePosix &&pipe_posix) {
   PipeBase::operator=(std::move(pipe_posix));

source/Host/windows/PipeWindows.cpp

 #include <atomic>
 #include <string>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 std::atomic<uint32_t> g_pipe_serial(0);
+constexpr llvm::StringLiteral g_pipe_name_prefix = "\\\\.\\Pipe\\";
+} // namespace
+
+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() {
+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;
+  }
 
-  m_read_fd = -1;
-  m_write_fd = -1;
   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 = "\\\\.\\Pipe\\";
+  std::string pipe_path = g_pipe_name_prefix;
   pipe_path.append(name);
 
   // 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.
+  // 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,
   }
   if (error.Success())
     name = pipe_name;
   return error;
 }
 
 Status PipeWindows::OpenAsReader(llvm::StringRef name,
                                  bool child_process_inherit) {
-  if (CanRead() || CanWrite())
+  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 (CanRead() || CanWrite())
+  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 = "\\\\.\\Pipe\\";
+  std::string pipe_path = g_pipe_name_prefix;
   pipe_path.append(name);
 
   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);
 

 }
 
 int PipeWindows::GetReadFileDescriptor() const { return m_read_fd; }
 
 int PipeWindows::GetWriteFileDescriptor() const { return m_write_fd; }
 
 int PipeWindows::ReleaseReadFileDescriptor() {
   if (!CanRead())
-    return -1;
+    return PipeWindows::kInvalidDescriptor;
   int result = m_read_fd;
-  m_read_fd = -1;
+  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 -1;
+    return PipeWindows::kInvalidDescriptor;
   int result = m_write_fd;
-  m_write_fd = -1;
+  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 = -1;
+  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 = -1;
+  m_write_fd = PipeWindows::kInvalidDescriptor;
   ZeroMemory(&m_write_overlapped, sizeof(m_write_overlapped));
 }
 
 void PipeWindows::Close() {
   CloseReadFileDescriptor();
   CloseWriteFileDescriptor();
 }
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

#endif
     // port is null when debug server should listen on domain socket - we're
     // not interested in port value but rather waiting for debug server to
     // become available.
     if (pass_comm_fd == -1) {
       if (url) {
 // Create a temporary file to get the stdout/stderr and redirect the output of
 // the command into this file. We will later read this file if all goes well
 // and fill the data into "command_output_ptr"
 #if defined(__APPLE__)
         // Binding to port zero, we need to figure out what port it ends up
         // using using a named pipe...
         error = socket_pipe.CreateWithUniqueName("debugserver-named-pipe",
                                                  false, named_pipe_path);
         if (error.Fail()) {
           if (log)
             log->Printf("GDBRemoteCommunication::%s() "
                         "named pipe creation failed: %s",
                         __FUNCTION__, error.AsCString());
           return error;
         }
         debugserver_args.AppendArgument(llvm::StringRef("--named-pipe"));
         debugserver_args.AppendArgument(named_pipe_path);
 #else
         // Binding to port zero, we need to figure out what port it ends up
         // using using an unnamed pipe...
         error = socket_pipe.CreateNew(true);
         if (error.Fail()) {
           if (log)
             log->Printf("GDBRemoteCommunication::%s() "
                         "unnamed pipe creation failed: %s",
                         __FUNCTION__, error.AsCString());
           return error;
         }
-        int write_fd = socket_pipe.GetWriteFileDescriptor();
+        pipe_t write = socket_pipe.GetWritePipe();
         debugserver_args.AppendArgument(llvm::StringRef("--pipe"));
-        debugserver_args.AppendArgument(llvm::to_string(write_fd));
+        debugserver_args.AppendArgument(llvm::to_string(write));
         launch_info.AppendCloseFileAction(socket_pipe.GetReadFileDescriptor());
 #endif
       } else {
         // No host and port given, so lets listen on our end and make the
         // debugserver connect to us..
         error = StartListenThread("127.0.0.1", 0);
         if (error.Fail()) {
           if (log)

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

if (port > 0)
       FreePort(port);
   }
   return error;
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qLaunchGDBServer(
     StringExtractorGDBRemote &packet) {
-#ifdef _WIN32
-  return SendErrorResponse(9);
-#else
   // Spawn a local debugserver as a platform so we can then attach or launch a
   // process...
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
   if (log)
     log->Printf("GDBRemoteCommunicationServerPlatform::%s() called",
                 __FUNCTION__);
 
if (!socket_name.empty()) {
     response.PutCString("socket_name:");
     response.PutCStringAsRawHex8(socket_name.c_str());
     response.PutChar(';');
   }
 
   PacketResult packet_result = SendPacketNoLock(response.GetString());
   if (packet_result != PacketResult::Success) {
     if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
-      ::kill(debugserver_pid, SIGINT);
+      Host::Kill(debugserver_pid, SIGINT);
   }
   return packet_result;
-#endif
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerPlatform::Handle_qQueryGDBServer(
     StringExtractorGDBRemote &packet) {
   if (m_pending_gdb_server.pid == LLDB_INVALID_PROCESS_ID)
     return SendErrorResponse(4);
 

tools/lldb-server/lldb-gdbserver.cpp

Status writeSocketIdToPipe(const char *const named_pipe_path,
   Pipe port_name_pipe;
   // Wait for 10 seconds for pipe to be opened.
   auto error = port_name_pipe.OpenAsWriterWithTimeout(named_pipe_path, false,
                                                       std::chrono::seconds{10});
   if (error.Fail())
     return error;
   return writeSocketIdToPipe(port_name_pipe, socket_id);
 }
 
-Status writeSocketIdToPipe(int unnamed_pipe_fd, const std::string &socket_id) {
-#if defined(_WIN32)
-  return Status("Unnamed pipes are not supported on Windows.");
-#else
-  Pipe port_pipe{Pipe::kInvalidDescriptor, unnamed_pipe_fd};
+Status writeSocketIdToPipe(lldb::pipe_t unnamed_pipe,
+                           const std::string &socket_id) {
+  Pipe port_pipe{LLDB_INVALID_PIPE, unnamed_pipe};
   return writeSocketIdToPipe(port_pipe, socket_id);
-#endif
 }
 
 void ConnectToRemote(MainLoop &mainloop,
                      GDBRemoteCommunicationServerLLGS &gdb_server,
                      bool reverse_connect, const char *const host_and_port,
                      const char *const progname, const char *const subcommand,
-                     const char *const named_pipe_path, int unnamed_pipe_fd,
+                     const char *const named_pipe_path, pipe_t unnamed_pipe,
                      int connection_fd) {
   Status error;
 
   std::unique_ptr<Connection> connection_up;
   if (connection_fd != -1) {
     // Build the connection string.
     char connection_url[512];
     snprintf(connection_url, sizeof(connection_url), "fd://%d", connection_fd);
if (reverse_connect) {
         if (named_pipe_path && named_pipe_path[0]) {
           error = writeSocketIdToPipe(named_pipe_path, socket_id);
           if (error.Fail())
             fprintf(stderr, "failed to write to the named pipe \'%s\': %s\n",
                     named_pipe_path, error.AsCString());
         }
         // If we have an unnamed pipe to write the socket id back to, do that
         // now.
-        else if (unnamed_pipe_fd >= 0) {
-          error = writeSocketIdToPipe(unnamed_pipe_fd, socket_id);
+        else if (unnamed_pipe != LLDB_INVALID_PIPE) {
+          error = writeSocketIdToPipe(unnamed_pipe, socket_id);
           if (error.Fail())
             fprintf(stderr, "failed to write to the unnamed pipe: %s\n",
                     error.AsCString());
         }
       } else {
         fprintf(stderr,
                 "unable to get the socket id for the listening connection\n");
       }
#endif
   argv++;
   int long_option_index = 0;
   int ch;
   std::string attach_target;
   std::string named_pipe_path;
   std::string log_file;
   StringRef
       log_channels; // e.g. "lldb process threads:gdb-remote default:linux all"
-  int unnamed_pipe_fd = -1;
+  lldb::pipe_t unnamed_pipe = LLDB_INVALID_PIPE;
   bool reverse_connect = false;
   int connection_fd = -1;
 
   // ProcessLaunchInfo launch_info;
   ProcessAttachInfo attach_info;
 
   bool show_usage = false;
   int option_error = 0;
while ((ch = getopt_long_only(argc, argv, short_options.c_str(),
 
     case 'N': // named pipe
       if (optarg && optarg[0])
         named_pipe_path = optarg;
       break;
 
     case 'U': // unnamed pipe
       if (optarg && optarg[0])
-        unnamed_pipe_fd = StringConvert::ToUInt32(optarg, -1);
+        unnamed_pipe = (pipe_t)StringConvert::ToUInt64(optarg, -1);
       break;
 
     case 'r':
       // Do nothing, native regs is the default these days
       break;
 
     case 'R':
       reverse_connect = true;
if (!attach_target.empty())
     handle_attach(gdb_server, attach_target);
   else if (argc > 0)
     handle_launch(gdb_server, argc, argv);
 
   // Print version info.
   printf("%s-%s", LLGS_PROGRAM_NAME, LLGS_VERSION_STR);
 
   ConnectToRemote(mainloop, gdb_server, reverse_connect, host_and_port,
-                  progname, subcommand, named_pipe_path.c_str(),
-                  unnamed_pipe_fd, connection_fd);
+                  progname, subcommand, named_pipe_path.c_str(), 
+                  unnamed_pipe, connection_fd);
 
   if (!gdb_server.IsConnected()) {
     fprintf(stderr, "no connection information provided, unable to run\n");
     display_usage(progname, subcommand);
     return 1;
   }
 
   mainloop.Run();
   fprintf(stderr, "lldb-server exiting...\n");
 
   return 0;
 }