This is an archive of the discontinued LLVM Phabricator instance.

Differential D5548

Move ConnectionFileDescriptor to posix-subfolder in preparation for implementing on Windows
ClosedPublic

Authored by zturner on Sep 30 2014, 1:22 PM.

Details

Reviewers
clayborg
jingham
Commits
rG93a66fc13abb: Move ConnectionFileDescriptor to platform-specific Host directory.
rLLDB219143: Move ConnectionFileDescriptor to platform-specific Host directory.
rL219143: Move ConnectionFileDescriptor to platform-specific Host directory.
Summary

ConnectionFileDescriptor needs a different implementation on Windows and non-Windows platforms due to some fundamental differences. This patch moves source\Core\ConnectionFileDescriptor.cpp to source\Core\posix\ConnectionFileDescriptorPosix.cpp, and similarly for the corresponding header file. Then, the original ConnectionFileDescriptor.h is replaced with a new implementation that includes the platform specific header file.

Currently this patch does not actually implement Windows' version of ConnectionFileDescriptor. It only makes the organizational changes necessary for this to happen in a subsequent patch. As such, with this patch, Windows will actually be compiling source\Core\posix\ConnectionFileDescriptor.cpp. When the windows version of CFD goes in, the CMake will be updated accordingly to compile the windows CFD.

This patch contains no functional changes, only code move.

Diff Detail

Event Timeline

zturner updated this revision to Diff 14244.Sep 30 2014, 1:22 PM
zturner retitled this revision from to Move ConnectionFileDescriptor to posix-subfolder in preparation for implementing on Windows.
zturner updated this object.
zturner edited the test plan for this revision. (Show Details)
zturner added reviewers: clayborg, jingham.
zturner added a subscriber: Unknown Object (MLST).
emaste added a subscriber: emaste.Sep 30 2014, 1:42 PM

I haven't looked closely at the proposed patch, but should CFD instead migrate to source/Host/...?

zturner added a comment.Sep 30 2014, 2:06 PM

Good question. Logically it seems a little too high level for Host to me.
Conceptually speaking, CFD is just a wrapper around one of any number of
host primitives. For example, it's a wrapper around a file, or a socket,
or a pipe, etc. It just allows you to treat all those things using the
same interface. Host seems more appropriate for providing lower-level
primitives. It's kind of a grey area here though, because the
implementation of CFD uses select(), which doesn't lend itself to a nice
port on Windows, basically the whole thing has to be re-written.

I brainstormed ways of lowering a select-like abstraction into Host so that
CFD could just be implemented without any platform specific stuff, but it's
not that easy since the semantics have some subtle differences that make it
difficult to present a generic interface.

zturner updated this revision to Diff 14288.Oct 1 2014, 11:14 AM

Same change as before, but with CFD moved to Host instead of to a platform-specific folder in Core. There's no functionality change here, just file re-organization.

clayborg accepted this revision.Oct 6 2014, 1:22 PM
clayborg edited edge metadata.

Looks good.

This revision is now accepted and ready to land.Oct 6 2014, 1:22 PM
zturner closed this revision.Oct 6 2014, 2:33 PM
zturner updated this revision to Diff 14473.

Closed by commit rL219143 (authored by @zturner).

Revision Contents

PathSize
include/
lldb/
Core/
Host/
15 lines
2 lines
posix/
119 lines
source/
API/
2 lines
Core/
1 line
2 lines
Host/
4 lines
macosx/
2 lines
posix/
812 lines
Interpreter/
2 lines
Plugins/
Platform/
gdb-server/
2 lines
Process/
MacOSX-Kernel/
2 lines
gdb-remote/
2 lines
2 lines
2 lines
2 lines
Target/
6 lines
tools/
lldb-gdbserver/
2 lines
lldb-platform/
2 lines

Diff 14288

include/lldb/Core/ConnectionFileDescriptor.h

  • This file was deleted.
//===-- ConnectionFileDescriptor.h ------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_ConnectionFileDescriptor_h_
#define liblldb_ConnectionFileDescriptor_h_
// C++ Includes
#include <atomic>
#include <memory>
#include "lldb/lldb-forward.h"
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Connection.h"
#include "lldb/Host/Mutex.h"
#include "lldb/Host/Pipe.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Host/IOObject.h"
namespace lldb_private {
class Error;
class Socket;
class SocketAddress;
class ConnectionFileDescriptor :
public Connection
{
public:
ConnectionFileDescriptor ();
ConnectionFileDescriptor (int fd, bool owns_fd);
virtual
~ConnectionFileDescriptor ();
virtual bool
IsConnected () const;
virtual lldb::ConnectionStatus
Connect (const char *s, Error *error_ptr);
virtual lldb::ConnectionStatus
Disconnect (Error *error_ptr);
virtual size_t
Read (void *dst,
size_t dst_len,
uint32_t timeout_usec,
lldb::ConnectionStatus &status,
Error *error_ptr);
virtual size_t
Write (const void *src,
size_t src_len,
lldb::ConnectionStatus &status,
Error *error_ptr);
lldb::ConnectionStatus
BytesAvailable (uint32_t timeout_usec, Error *error_ptr);
bool
InterruptRead ();
lldb::IOObjectSP GetReadObject() { return m_read_sp; }
const lldb::IOObjectSP GetReadObject() const { return m_read_sp; }
uint16_t GetListeningPort(uint32_t timeout_sec);
protected:
void
OpenCommandPipe ();
void
CloseCommandPipe ();
lldb::ConnectionStatus
SocketListen (const char *host_and_port, Error *error_ptr);
lldb::ConnectionStatus
ConnectTCP (const char *host_and_port, Error *error_ptr);
lldb::ConnectionStatus
ConnectUDP (const char *args, Error *error_ptr);
lldb::ConnectionStatus
NamedSocketConnect (const char *socket_name, Error *error_ptr);
lldb::ConnectionStatus
NamedSocketAccept (const char *socket_name, Error *error_ptr);
lldb::IOObjectSP m_read_sp;
lldb::IOObjectSP m_write_sp;
Predicate<uint16_t> m_port_predicate; // Used when binding to port zero to wait for the thread
// that creates the socket, binds and listens to resolve
// the port number.
Pipe m_pipe;
Mutex m_mutex;
std::atomic<bool> m_shutting_down; // This marks that we are shutting down so if we get woken up from
// BytesAvailable to disconnect, we won't try to read again.
bool m_waiting_for_accept;
private:
DISALLOW_COPY_AND_ASSIGN (ConnectionFileDescriptor);
};
} // namespace lldb_private
#endif // liblldb_ConnectionFileDescriptor_h_

include/lldb/Host/ConnectionFileDescriptor.h

  • This file was added.
//===-- ConnectionFileDescriptor.h ------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Host_ConnectionFileDescriptor_h_
#define liblldb_Host_ConnectionFileDescriptor_h_
#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
#endif

include/lldb/Host/Editline.h

Context not available.
#include <string> #include <string>
#include <vector> #include <vector>
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Host/Condition.h" #include "lldb/Host/Condition.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Mutex.h" #include "lldb/Host/Mutex.h"
#include "lldb/Host/Predicate.h" #include "lldb/Host/Predicate.h"
Context not available.

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

  • This file was added.
//===-- ConnectionFileDescriptorPosix.h -------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Host_posix_ConnectionFileDescriptorPosix_h_
#define liblldb_Host_posix_ConnectionFileDescriptorPosix_h_
// C++ Includes
#include <atomic>
#include <memory>
#include "lldb/lldb-forward.h"
// Other libraries and framework includes
// Project includes
#include "lldb/Core/Connection.h"
#include "lldb/Host/Mutex.h"
#include "lldb/Host/Pipe.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Host/IOObject.h"
namespace lldb_private {
class Error;
class Socket;
class SocketAddress;
class ConnectionFileDescriptor :
public Connection
{
public:
ConnectionFileDescriptor ();
ConnectionFileDescriptor (int fd, bool owns_fd);
virtual
~ConnectionFileDescriptor ();
virtual bool
IsConnected () const;
virtual lldb::ConnectionStatus
Connect (const char *s, Error *error_ptr);
virtual lldb::ConnectionStatus
Disconnect (Error *error_ptr);
virtual size_t
Read (void *dst,
size_t dst_len,
uint32_t timeout_usec,
lldb::ConnectionStatus &status,
Error *error_ptr);
virtual size_t
Write (const void *src,
size_t src_len,
lldb::ConnectionStatus &status,
Error *error_ptr);
lldb::ConnectionStatus
BytesAvailable (uint32_t timeout_usec, Error *error_ptr);
bool
InterruptRead ();
lldb::IOObjectSP GetReadObject() { return m_read_sp; }
const lldb::IOObjectSP GetReadObject() const { return m_read_sp; }
uint16_t GetListeningPort(uint32_t timeout_sec);
protected:
void
OpenCommandPipe ();
void
CloseCommandPipe ();
lldb::ConnectionStatus
SocketListen (const char *host_and_port, Error *error_ptr);
lldb::ConnectionStatus
ConnectTCP (const char *host_and_port, Error *error_ptr);
lldb::ConnectionStatus
ConnectUDP (const char *args, Error *error_ptr);
lldb::ConnectionStatus
NamedSocketConnect (const char *socket_name, Error *error_ptr);
lldb::ConnectionStatus
NamedSocketAccept (const char *socket_name, Error *error_ptr);
lldb::IOObjectSP m_read_sp;
lldb::IOObjectSP m_write_sp;
Predicate<uint16_t> m_port_predicate; // Used when binding to port zero to wait for the thread
// that creates the socket, binds and listens to resolve
// the port number.
Pipe m_pipe;
Mutex m_mutex;
std::atomic<bool> m_shutting_down; // This marks that we are shutting down so if we get woken up from
// BytesAvailable to disconnect, we won't try to read again.
bool m_waiting_for_accept;
private:
DISALLOW_COPY_AND_ASSIGN (ConnectionFileDescriptor);
};
} // namespace lldb_private
#endif // liblldb_ConnectionFileDescriptor_h_

source/API/SBCommunication.cpp

Context not available.
#include "lldb/API/SBCommunication.h" #include "lldb/API/SBCommunication.h"
#include "lldb/API/SBBroadcaster.h" #include "lldb/API/SBBroadcaster.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Context not available.

source/Core/CMakeLists.txt

Context not available.
Broadcaster.cpp Broadcaster.cpp
Communication.cpp Communication.cpp
Connection.cpp Connection.cpp
ConnectionFileDescriptor.cpp
ConnectionMachPort.cpp ConnectionMachPort.cpp
ConnectionSharedMemory.cpp ConnectionSharedMemory.cpp
ConstString.cpp ConstString.cpp
Context not available.

source/Core/ConnectionFileDescriptor.cpp

  • This file was deleted.
//===-- ConnectionFileDescriptor.cpp ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#if defined(__APPLE__)
// Enable this special support for Apple builds where we can have unlimited
// select bounds. We tried switching to poll() and kqueue and we were panicing
// the kernel, so we have to stick with select for now.
#define _DARWIN_UNLIMITED_SELECT
#endif
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Host/Config.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Host/SocketAddress.h"
#include "lldb/Host/Socket.h"
// C Includes
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#ifndef LLDB_DISABLE_POSIX
#include <termios.h>
#endif
// C++ Includes
// Other libraries and framework includes
#include "llvm/Support/ErrorHandling.h"
#if defined(__APPLE__)
#include "llvm/ADT/SmallVector.h"
#endif
// Project includes
#include "lldb/lldb-private-log.h"
#include "lldb/Core/Communication.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h"
#include "lldb/Host/Socket.h"
#include "lldb/Interpreter/Args.h"
using namespace lldb;
using namespace lldb_private;
ConnectionFileDescriptor::ConnectionFileDescriptor () :
Connection(),
m_pipe (),
m_mutex (Mutex::eMutexTypeRecursive),
m_shutting_down (false),
m_waiting_for_accept (false)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor ()",
static_cast<void*>(this));
}
ConnectionFileDescriptor::ConnectionFileDescriptor (int fd, bool owns_fd) :
Connection(),
m_pipe (),
m_mutex (Mutex::eMutexTypeRecursive),
m_shutting_down (false),
m_waiting_for_accept (false)
{
m_write_sp.reset(new File(fd, owns_fd));
m_read_sp.reset(new File(fd, false));
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = %i, owns_fd = %i)",
static_cast<void*>(this), fd, owns_fd);
OpenCommandPipe ();
}
ConnectionFileDescriptor::~ConnectionFileDescriptor ()
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::~ConnectionFileDescriptor ()",
static_cast<void*>(this));
Disconnect (NULL);
CloseCommandPipe ();
}
void
ConnectionFileDescriptor::OpenCommandPipe ()
{
CloseCommandPipe();
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
// Make the command file descriptor here:
if (!m_pipe.Open())
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe () - could not make pipe: %s",
static_cast<void*>(this), strerror(errno));
}
else
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe() - success readfd=%d writefd=%d",
static_cast<void*>(this),
m_pipe.GetReadFileDescriptor(),
m_pipe.GetWriteFileDescriptor());
}
}
void
ConnectionFileDescriptor::CloseCommandPipe ()
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::CloseCommandPipe()",
static_cast<void*>(this));
m_pipe.Close();
}
bool
ConnectionFileDescriptor::IsConnected () const
{
return (m_read_sp && m_read_sp->IsValid()) || (m_write_sp && m_write_sp->IsValid());
}
ConnectionStatus
ConnectionFileDescriptor::Connect (const char *s, Error *error_ptr)
{
Mutex::Locker locker (m_mutex);
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Connect (url = '%s')",
static_cast<void*>(this), s);
OpenCommandPipe();
if (s && s[0])
{
if (strstr(s, "listen://") == s)
{
// listen://HOST:PORT
return SocketListen (s + strlen("listen://"), error_ptr);
}
else if (strstr(s, "accept://") == s)
{
// unix://SOCKNAME
return NamedSocketAccept (s + strlen("accept://"), error_ptr);
}
else if (strstr(s, "unix-accept://") == s)
{
// unix://SOCKNAME
return NamedSocketAccept (s + strlen("unix-accept://"), error_ptr);
}
else if (strstr(s, "connect://") == s)
{
return ConnectTCP (s + strlen("connect://"), error_ptr);
}
else if (strstr(s, "tcp-connect://") == s)
{
return ConnectTCP (s + strlen("tcp-connect://"), error_ptr);
}
else if (strstr(s, "udp://") == s)
{
return ConnectUDP (s + strlen("udp://"), error_ptr);
}
#ifndef LLDB_DISABLE_POSIX
else if (strstr(s, "fd://") == s)
{
// Just passing a native file descriptor within this current process
// that is already opened (possibly from a service or other source).
s += strlen ("fd://");
bool success = false;
int fd = Args::StringToSInt32 (s, -1, 0, &success);
if (success)
{
// We have what looks to be a valid file descriptor, but we
// should make sure it is. We currently are doing this by trying to
// get the flags from the file descriptor and making sure it
// isn't a bad fd.
errno = 0;
int flags = ::fcntl (fd, F_GETFL, 0);
if (flags == -1 || errno == EBADF)
{
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("stale file descriptor: %s", s);
m_read_sp.reset();
m_write_sp.reset();
return eConnectionStatusError;
}
else
{
// Don't take ownership of a file descriptor that gets passed
// to us since someone else opened the file descriptor and
// handed it to us.
// TODO: Since are using a URL to open connection we should
// eventually parse options using the web standard where we
// have "fd://123?opt1=value;opt2=value" and we can have an
// option be "owns=1" or "owns=0" or something like this to
// allow us to specify this. For now, we assume we must
// assume we don't own it.
std::unique_ptr<Socket> tcp_socket;
tcp_socket.reset(new Socket(fd, Socket::ProtocolTcp, false));
// Try and get a socket option from this file descriptor to
// see if this is a socket and set m_is_socket accordingly.
int resuse;
bool is_socket = !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
if (is_socket)
{
m_read_sp = std::move(tcp_socket);
m_write_sp = m_read_sp;
}
else
{
m_read_sp.reset(new File(fd, false));
m_write_sp.reset(new File(fd, false));
}
return eConnectionStatusSuccess;
}
}
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("invalid file descriptor: \"fd://%s\"", s);
m_read_sp.reset();
m_write_sp.reset();
return eConnectionStatusError;
}
else if (strstr(s, "file://") == s)
{
// file:///PATH
const char *path = s + strlen("file://");
int fd = -1;
do
{
fd = ::open (path, O_RDWR);
} while (fd == -1 && errno == EINTR);
if (fd == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
return eConnectionStatusError;
}
if (::isatty(fd))
{
// Set up serial terminal emulation
struct termios options;
::tcgetattr (fd, &options);
// Set port speed to maximum
::cfsetospeed (&options, B115200);
::cfsetispeed (&options, B115200);
// Raw input, disable echo and signals
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// Make sure only one character is needed to return from a read
options.c_cc[VMIN] = 1;
options.c_cc[VTIME] = 0;
::tcsetattr (fd, TCSANOW, &options);
}
int flags = ::fcntl (fd, F_GETFL, 0);
if (flags >= 0)
{
if ((flags & O_NONBLOCK) == 0)
{
flags |= O_NONBLOCK;
::fcntl (fd, F_SETFL, flags);
}
}
m_read_sp.reset(new File(fd, true));
m_write_sp.reset(new File(fd, false));
return eConnectionStatusSuccess;
}
#endif
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("unsupported connection URL: '%s'", s);
return eConnectionStatusError;
}
if (error_ptr)
error_ptr->SetErrorString("invalid connect arguments");
return eConnectionStatusError;
}
bool
ConnectionFileDescriptor::InterruptRead()
{
return m_pipe.Write("i", 1) == 1;
}
ConnectionStatus
ConnectionFileDescriptor::Disconnect (Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect ()",
static_cast<void*>(this));
ConnectionStatus status = eConnectionStatusSuccess;
if (!IsConnected())
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Nothing to disconnect",
static_cast<void*>(this));
return eConnectionStatusSuccess;
}
if (m_read_sp && m_read_sp->IsValid() && m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
static_cast<Socket&>(*m_read_sp).PreDisconnect();
// Try to get the ConnectionFileDescriptor's mutex. If we fail, that is quite likely
// because somebody is doing a blocking read on our file descriptor. If that's the case,
// then send the "q" char to the command file channel so the read will wake up and the connection
// will then know to shut down.
m_shutting_down = true;
Mutex::Locker locker;
bool got_lock = locker.TryLock (m_mutex);
if (!got_lock)
{
if (m_pipe.WriteDescriptorIsValid())
{
int result;
result = m_pipe.Write("q", 1) == 1;
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, sent 'q' to %d, result = %d.",
static_cast<void*>(this), m_pipe.GetWriteFileDescriptor(), result);
}
else if (log)
{
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, but no command pipe is available.",
static_cast<void*>(this));
}
locker.Lock (m_mutex);
}
Error error = m_read_sp->Close();
Error error2 = m_write_sp->Close();
if (error.Fail() || error2.Fail())
status = eConnectionStatusError;
if (error_ptr)
*error_ptr = error.Fail() ? error : error2;
m_shutting_down = false;
return status;
}
size_t
ConnectionFileDescriptor::Read (void *dst,
size_t dst_len,
uint32_t timeout_usec,
ConnectionStatus &status,
Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
Mutex::Locker locker;
bool got_lock = locker.TryLock (m_mutex);
if (!got_lock)
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::Read () failed to get the connection lock.",
static_cast<void*>(this));
if (error_ptr)
error_ptr->SetErrorString ("failed to get the connection lock for read.");
status = eConnectionStatusTimedOut;
return 0;
}
else if (m_shutting_down)
return eConnectionStatusError;
status = BytesAvailable (timeout_usec, error_ptr);
if (status != eConnectionStatusSuccess)
return 0;
Error error;
size_t bytes_read = dst_len;
error = m_read_sp->Read(dst, bytes_read);
if (log)
{
log->Printf("%p ConnectionFileDescriptor::Read() fd = %" PRIu64 ", dst = %p, dst_len = %" PRIu64 ") => %" PRIu64 ", error = %s",
static_cast<void*>(this),
static_cast<uint64_t>(m_read_sp->GetWaitableHandle()),
static_cast<void*>(dst),
static_cast<uint64_t>(dst_len),
static_cast<uint64_t>(bytes_read),
error.AsCString());
}
if (bytes_read == 0)
{
error.Clear(); // End-of-file. Do not automatically close; pass along for the end-of-file handlers.
status = eConnectionStatusEndOfFile;
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
uint32_t error_value = error.GetError();
switch (error_value)
{
case EAGAIN: // The file was marked for non-blocking I/O, and no data were ready to be read.
if (m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
status = eConnectionStatusTimedOut;
else
status = eConnectionStatusSuccess;
return 0;
case EFAULT: // Buf points outside the allocated address space.
case EINTR: // A read from a slow device was interrupted before any data arrived by the delivery of a signal.
case EINVAL: // The pointer associated with fildes was negative.
case EIO: // An I/O error occurred while reading from the file system.
// The process group is orphaned.
// The file is a regular file, nbyte is greater than 0,
// the starting position is before the end-of-file, and
// the starting position is greater than or equal to the
// offset maximum established for the open file
// descriptor associated with fildes.
case EISDIR: // An attempt is made to read a directory.
case ENOBUFS: // An attempt to allocate a memory buffer fails.
case ENOMEM: // Insufficient memory is available.
status = eConnectionStatusError;
break; // Break to close....
case ENOENT: // no such file or directory
case EBADF: // fildes is not a valid file or socket descriptor open for reading.
case ENXIO: // An action is requested of a device that does not exist..
// A requested action cannot be performed by the device.
case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket.
case ENOTCONN: // A read is attempted on an unconnected socket.
status = eConnectionStatusLostConnection;
break; // Break to close....
case ETIMEDOUT: // A transmission timeout occurs during a read attempt on a socket.
status = eConnectionStatusTimedOut;
return 0;
default:
if (log)
log->Printf("%p ConnectionFileDescriptor::Read (), unexpected error: %s",
static_cast<void*>(this), strerror(error_value));
status = eConnectionStatusError;
break; // Break to close....
}
return 0;
}
return bytes_read;
}
size_t
ConnectionFileDescriptor::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Write (src = %p, src_len = %" PRIu64 ")",
static_cast<void*>(this), static_cast<const void*>(src),
static_cast<uint64_t>(src_len));
if (!IsConnected ())
{
if (error_ptr)
error_ptr->SetErrorString("not connected");
status = eConnectionStatusNoConnection;
return 0;
}
Error error;
size_t bytes_sent = src_len;
error = m_write_sp->Write(src, bytes_sent);
if (log)
{
log->Printf ("%p ConnectionFileDescriptor::Write(fd = %" PRIu64 ", src = %p, src_len = %" PRIu64 ") => %" PRIu64 " (error = %s)",
static_cast<void*>(this),
static_cast<uint64_t>(m_write_sp->GetWaitableHandle()),
static_cast<const void*>(src),
static_cast<uint64_t>(src_len),
static_cast<uint64_t>(bytes_sent),
error.AsCString());
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
switch (error.GetError())
{
case EAGAIN:
case EINTR:
status = eConnectionStatusSuccess;
return 0;
case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket.
case ENOTCONN: // A read is attempted on an unconnected socket.
status = eConnectionStatusLostConnection;
break; // Break to close....
default:
status = eConnectionStatusError;
break; // Break to close....
}
return 0;
}
status = eConnectionStatusSuccess;
return bytes_sent;
}
// This ConnectionFileDescriptor::BytesAvailable() uses select().
//
// PROS:
// - select is consistent across most unix platforms
// - The Apple specific version allows for unlimited fds in the fd_sets by
// setting the _DARWIN_UNLIMITED_SELECT define prior to including the
// required header files.
// CONS:
// - on non-Apple platforms, only supports file descriptors up to FD_SETSIZE.
// This implementation will assert if it runs into that hard limit to let
// users know that another ConnectionFileDescriptor::BytesAvailable() should
// be used or a new version of ConnectionFileDescriptor::BytesAvailable()
// should be written for the system that is running into the limitations.
#if defined(__APPLE__)
#define FD_SET_DATA(fds) fds.data()
#else
#define FD_SET_DATA(fds) &fds
#endif
ConnectionStatus
ConnectionFileDescriptor::BytesAvailable (uint32_t timeout_usec, Error *error_ptr)
{
// Don't need to take the mutex here separately since we are only called from Read. If we
// ever get used more generally we will need to lock here as well.
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)",
static_cast<void*>(this), timeout_usec);
struct timeval *tv_ptr;
struct timeval tv;
if (timeout_usec == UINT32_MAX)
{
// Inifinite wait...
tv_ptr = nullptr;
}
else
{
TimeValue time_value;
time_value.OffsetWithMicroSeconds (timeout_usec);
tv.tv_sec = time_value.seconds();
tv.tv_usec = time_value.microseconds();
tv_ptr = &tv;
}
// Make a copy of the file descriptors to make sure we don't
// have another thread change these values out from under us
// and cause problems in the loop below where like in FS_SET()
const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle();
const int pipe_fd = m_pipe.GetReadFileDescriptor();
if (handle != IOObject::kInvalidHandleValue)
{
#if defined(_MSC_VER)
// select() won't accept pipes on Windows. The entire Windows codepath needs to be
// converted over to using WaitForMultipleObjects and event HANDLEs, but for now at least
// this will allow ::select() to not return an error.
const bool have_pipe_fd = false;
#else
const bool have_pipe_fd = pipe_fd >= 0;
#if !defined(__APPLE__)
assert (handle < FD_SETSIZE);
if (have_pipe_fd)
assert (pipe_fd < FD_SETSIZE);
#endif
#endif
while (handle == m_read_sp->GetWaitableHandle())
{
const int nfds = std::max<int>(handle, pipe_fd) + 1;
#if defined(__APPLE__)
llvm::SmallVector<fd_set, 1> read_fds;
read_fds.resize((nfds/FD_SETSIZE) + 1);
for (size_t i=0; i<read_fds.size(); ++i)
FD_ZERO (&read_fds[i]);
// FD_SET doesn't bounds check, it just happily walks off the end
// but we have taken care of making the extra storage with our
// SmallVector of fd_set objects
#else
fd_set read_fds;
FD_ZERO (&read_fds);
#endif
FD_SET (handle, FD_SET_DATA(read_fds));
if (have_pipe_fd)
FD_SET (pipe_fd, FD_SET_DATA(read_fds));
Error error;
if (log)
{
if (have_pipe_fd)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p)...",
static_cast<void*>(this), nfds, handle, pipe_fd,
static_cast<void*>(tv_ptr));
else
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p)...",
static_cast<void*>(this), nfds, handle,
static_cast<void*>(tv_ptr));
}
const int num_set_fds = ::select (nfds, FD_SET_DATA(read_fds), NULL, NULL, tv_ptr);
if (num_set_fds < 0)
error.SetErrorToErrno();
else
error.Clear();
if (log)
{
if (have_pipe_fd)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p) => %d, error = %s",
static_cast<void*>(this), nfds, handle,
pipe_fd, static_cast<void*>(tv_ptr), num_set_fds,
error.AsCString());
else
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p) => %d, error = %s",
static_cast<void*>(this), nfds, handle,
static_cast<void*>(tv_ptr), num_set_fds,
error.AsCString());
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
switch (error.GetError())
{
case EBADF: // One of the descriptor sets specified an invalid descriptor.
return eConnectionStatusLostConnection;
case EINVAL: // The specified time limit is invalid. One of its components is negative or too large.
default: // Other unknown error
return eConnectionStatusError;
case EAGAIN: // The kernel was (perhaps temporarily) unable to
// allocate the requested number of file descriptors,
// or we have non-blocking IO
case EINTR: // A signal was delivered before the time limit
// expired and before any of the selected events
// occurred.
break; // Lets keep reading to until we timeout
}
}
else if (num_set_fds == 0)
{
return eConnectionStatusTimedOut;
}
else if (num_set_fds > 0)
{
if (FD_ISSET(handle, FD_SET_DATA(read_fds)))
return eConnectionStatusSuccess;
if (have_pipe_fd && FD_ISSET(pipe_fd, FD_SET_DATA(read_fds)))
{
// We got a command to exit. Read the data from that pipe:
char buffer[16];
ssize_t bytes_read;
do
{
bytes_read = ::read (pipe_fd, buffer, sizeof(buffer));
} while (bytes_read < 0 && errno == EINTR);
switch (buffer[0])
{
case 'q':
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.",
static_cast<void*>(this),
static_cast<int>(bytes_read), buffer);
return eConnectionStatusEndOfFile;
case 'i':
// Interrupt the current read
return eConnectionStatusInterrupted;
}
}
}
}
}
if (error_ptr)
error_ptr->SetErrorString("not connected");
return eConnectionStatusLostConnection;
}
ConnectionStatus
ConnectionFileDescriptor::NamedSocketAccept (const char *socket_name, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::UnixDomainAccept(socket_name, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::NamedSocketConnect (const char *socket_name, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::UnixDomainConnect(socket_name, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::SocketListen(const char *s, Error *error_ptr)
{
m_port_predicate.SetValue(0, eBroadcastNever);
Socket* socket = nullptr;
m_waiting_for_accept = true;
Error error = Socket::TcpListen(s, socket, &m_port_predicate);
if (error_ptr)
*error_ptr = error;
if (error.Fail())
return eConnectionStatusError;
std::unique_ptr<Socket> listening_socket_up;
listening_socket_up.reset(socket);
socket = nullptr;
error = listening_socket_up->BlockingAccept(s, socket);
listening_socket_up.reset();
if (error_ptr)
*error_ptr = error;
if (error.Fail())
return eConnectionStatusError;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::ConnectTCP(const char *s, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::TcpConnect(s, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::ConnectUDP(const char *s, Error *error_ptr)
{
Socket* send_socket = nullptr;
Socket* recv_socket = nullptr;
Error error = Socket::UdpConnect(s, send_socket, recv_socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(send_socket);
m_read_sp.reset(recv_socket);
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
uint16_t ConnectionFileDescriptor::GetListeningPort(uint32_t timeout_sec)
{
uint16_t bound_port = 0;
if (timeout_sec == UINT32_MAX)
m_port_predicate.WaitForValueNotEqualTo (0, bound_port);
else
{
TimeValue timeout = TimeValue::Now();
timeout.OffsetWithSeconds(timeout_sec);
m_port_predicate.WaitForValueNotEqualTo (0, bound_port, &timeout);
}
return bound_port;
}

source/Core/Debugger.cpp

Context not available.
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/RegisterValue.h" #include "lldb/Core/RegisterValue.h"
Context not available.
#include "lldb/DataFormatters/DataVisualization.h" #include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/DataFormatters/FormatManager.h" #include "lldb/DataFormatters/FormatManager.h"
#include "lldb/DataFormatters/TypeSummary.h" #include "lldb/DataFormatters/TypeSummary.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/Terminal.h" #include "lldb/Host/Terminal.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
Context not available.

source/Host/CMakeLists.txt

Context not available.
common/TimeValue.cpp common/TimeValue.cpp
) )
add_host_subdirectory(posix
posix/ConnectionFileDescriptorPosix.cpp
)
if (CMAKE_SYSTEM_NAME MATCHES "Windows") if (CMAKE_SYSTEM_NAME MATCHES "Windows")
add_host_subdirectory(windows add_host_subdirectory(windows
windows/Condition.cpp windows/Condition.cpp
Context not available.

source/Host/macosx/Host.mm

Context not available.
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/DataExtractor.h" #include "lldb/Core/DataExtractor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
Context not available.

source/Host/posix/ConnectionFileDescriptorPosix.cpp

  • This file was added.
//===-- ConnectionFileDescriptorPosix.cpp -----------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#if defined(__APPLE__)
// Enable this special support for Apple builds where we can have unlimited
// select bounds. We tried switching to poll() and kqueue and we were panicing
// the kernel, so we have to stick with select for now.
#define _DARWIN_UNLIMITED_SELECT
#endif
#include "lldb/Host/posix/ConnectionFileDescriptorPosix.h"
#include "lldb/Host/Config.h"
#include "lldb/Host/IOObject.h"
#include "lldb/Host/SocketAddress.h"
#include "lldb/Host/Socket.h"
// C Includes
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#ifndef LLDB_DISABLE_POSIX
#include <termios.h>
#endif
// C++ Includes
// Other libraries and framework includes
#include "llvm/Support/ErrorHandling.h"
#if defined(__APPLE__)
#include "llvm/ADT/SmallVector.h"
#endif
// Project includes
#include "lldb/lldb-private-log.h"
#include "lldb/Core/Communication.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Timer.h"
#include "lldb/Host/Host.h"
#include "lldb/Host/Socket.h"
#include "lldb/Interpreter/Args.h"
using namespace lldb;
using namespace lldb_private;
ConnectionFileDescriptor::ConnectionFileDescriptor () :
Connection(),
m_pipe (),
m_mutex (Mutex::eMutexTypeRecursive),
m_shutting_down (false),
m_waiting_for_accept (false)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor ()",
static_cast<void*>(this));
}
ConnectionFileDescriptor::ConnectionFileDescriptor (int fd, bool owns_fd) :
Connection(),
m_pipe (),
m_mutex (Mutex::eMutexTypeRecursive),
m_shutting_down (false),
m_waiting_for_accept (false)
{
m_write_sp.reset(new File(fd, owns_fd));
m_read_sp.reset(new File(fd, false));
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = %i, owns_fd = %i)",
static_cast<void*>(this), fd, owns_fd);
OpenCommandPipe ();
}
ConnectionFileDescriptor::~ConnectionFileDescriptor ()
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p ConnectionFileDescriptor::~ConnectionFileDescriptor ()",
static_cast<void*>(this));
Disconnect (NULL);
CloseCommandPipe ();
}
void
ConnectionFileDescriptor::OpenCommandPipe ()
{
CloseCommandPipe();
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
// Make the command file descriptor here:
if (!m_pipe.Open())
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe () - could not make pipe: %s",
static_cast<void*>(this), strerror(errno));
}
else
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::OpenCommandPipe() - success readfd=%d writefd=%d",
static_cast<void*>(this),
m_pipe.GetReadFileDescriptor(),
m_pipe.GetWriteFileDescriptor());
}
}
void
ConnectionFileDescriptor::CloseCommandPipe ()
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::CloseCommandPipe()",
static_cast<void*>(this));
m_pipe.Close();
}
bool
ConnectionFileDescriptor::IsConnected () const
{
return (m_read_sp && m_read_sp->IsValid()) || (m_write_sp && m_write_sp->IsValid());
}
ConnectionStatus
ConnectionFileDescriptor::Connect (const char *s, Error *error_ptr)
{
Mutex::Locker locker (m_mutex);
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Connect (url = '%s')",
static_cast<void*>(this), s);
OpenCommandPipe();
if (s && s[0])
{
if (strstr(s, "listen://") == s)
{
// listen://HOST:PORT
return SocketListen (s + strlen("listen://"), error_ptr);
}
else if (strstr(s, "accept://") == s)
{
// unix://SOCKNAME
return NamedSocketAccept (s + strlen("accept://"), error_ptr);
}
else if (strstr(s, "unix-accept://") == s)
{
// unix://SOCKNAME
return NamedSocketAccept (s + strlen("unix-accept://"), error_ptr);
}
else if (strstr(s, "connect://") == s)
{
return ConnectTCP (s + strlen("connect://"), error_ptr);
}
else if (strstr(s, "tcp-connect://") == s)
{
return ConnectTCP (s + strlen("tcp-connect://"), error_ptr);
}
else if (strstr(s, "udp://") == s)
{
return ConnectUDP (s + strlen("udp://"), error_ptr);
}
#ifndef LLDB_DISABLE_POSIX
else if (strstr(s, "fd://") == s)
{
// Just passing a native file descriptor within this current process
// that is already opened (possibly from a service or other source).
s += strlen ("fd://");
bool success = false;
int fd = Args::StringToSInt32 (s, -1, 0, &success);
if (success)
{
// We have what looks to be a valid file descriptor, but we
// should make sure it is. We currently are doing this by trying to
// get the flags from the file descriptor and making sure it
// isn't a bad fd.
errno = 0;
int flags = ::fcntl (fd, F_GETFL, 0);
if (flags == -1 || errno == EBADF)
{
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("stale file descriptor: %s", s);
m_read_sp.reset();
m_write_sp.reset();
return eConnectionStatusError;
}
else
{
// Don't take ownership of a file descriptor that gets passed
// to us since someone else opened the file descriptor and
// handed it to us.
// TODO: Since are using a URL to open connection we should
// eventually parse options using the web standard where we
// have "fd://123?opt1=value;opt2=value" and we can have an
// option be "owns=1" or "owns=0" or something like this to
// allow us to specify this. For now, we assume we must
// assume we don't own it.
std::unique_ptr<Socket> tcp_socket;
tcp_socket.reset(new Socket(fd, Socket::ProtocolTcp, false));
// Try and get a socket option from this file descriptor to
// see if this is a socket and set m_is_socket accordingly.
int resuse;
bool is_socket = !!tcp_socket->GetOption(SOL_SOCKET, SO_REUSEADDR, resuse);
if (is_socket)
{
m_read_sp = std::move(tcp_socket);
m_write_sp = m_read_sp;
}
else
{
m_read_sp.reset(new File(fd, false));
m_write_sp.reset(new File(fd, false));
}
return eConnectionStatusSuccess;
}
}
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("invalid file descriptor: \"fd://%s\"", s);
m_read_sp.reset();
m_write_sp.reset();
return eConnectionStatusError;
}
else if (strstr(s, "file://") == s)
{
// file:///PATH
const char *path = s + strlen("file://");
int fd = -1;
do
{
fd = ::open (path, O_RDWR);
} while (fd == -1 && errno == EINTR);
if (fd == -1)
{
if (error_ptr)
error_ptr->SetErrorToErrno();
return eConnectionStatusError;
}
if (::isatty(fd))
{
// Set up serial terminal emulation
struct termios options;
::tcgetattr (fd, &options);
// Set port speed to maximum
::cfsetospeed (&options, B115200);
::cfsetispeed (&options, B115200);
// Raw input, disable echo and signals
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
// Make sure only one character is needed to return from a read
options.c_cc[VMIN] = 1;
options.c_cc[VTIME] = 0;
::tcsetattr (fd, TCSANOW, &options);
}
int flags = ::fcntl (fd, F_GETFL, 0);
if (flags >= 0)
{
if ((flags & O_NONBLOCK) == 0)
{
flags |= O_NONBLOCK;
::fcntl (fd, F_SETFL, flags);
}
}
m_read_sp.reset(new File(fd, true));
m_write_sp.reset(new File(fd, false));
return eConnectionStatusSuccess;
}
#endif
if (error_ptr)
error_ptr->SetErrorStringWithFormat ("unsupported connection URL: '%s'", s);
return eConnectionStatusError;
}
if (error_ptr)
error_ptr->SetErrorString("invalid connect arguments");
return eConnectionStatusError;
}
bool
ConnectionFileDescriptor::InterruptRead()
{
return m_pipe.Write("i", 1) == 1;
}
ConnectionStatus
ConnectionFileDescriptor::Disconnect (Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect ()",
static_cast<void*>(this));
ConnectionStatus status = eConnectionStatusSuccess;
if (!IsConnected())
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Nothing to disconnect",
static_cast<void*>(this));
return eConnectionStatusSuccess;
}
if (m_read_sp && m_read_sp->IsValid() && m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
static_cast<Socket&>(*m_read_sp).PreDisconnect();
// Try to get the ConnectionFileDescriptor's mutex. If we fail, that is quite likely
// because somebody is doing a blocking read on our file descriptor. If that's the case,
// then send the "q" char to the command file channel so the read will wake up and the connection
// will then know to shut down.
m_shutting_down = true;
Mutex::Locker locker;
bool got_lock = locker.TryLock (m_mutex);
if (!got_lock)
{
if (m_pipe.WriteDescriptorIsValid())
{
int result;
result = m_pipe.Write("q", 1) == 1;
if (log)
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, sent 'q' to %d, result = %d.",
static_cast<void*>(this), m_pipe.GetWriteFileDescriptor(), result);
}
else if (log)
{
log->Printf ("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, but no command pipe is available.",
static_cast<void*>(this));
}
locker.Lock (m_mutex);
}
Error error = m_read_sp->Close();
Error error2 = m_write_sp->Close();
if (error.Fail() || error2.Fail())
status = eConnectionStatusError;
if (error_ptr)
*error_ptr = error.Fail() ? error : error2;
m_shutting_down = false;
return status;
}
size_t
ConnectionFileDescriptor::Read (void *dst,
size_t dst_len,
uint32_t timeout_usec,
ConnectionStatus &status,
Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
Mutex::Locker locker;
bool got_lock = locker.TryLock (m_mutex);
if (!got_lock)
{
if (log)
log->Printf ("%p ConnectionFileDescriptor::Read () failed to get the connection lock.",
static_cast<void*>(this));
if (error_ptr)
error_ptr->SetErrorString ("failed to get the connection lock for read.");
status = eConnectionStatusTimedOut;
return 0;
}
else if (m_shutting_down)
return eConnectionStatusError;
status = BytesAvailable (timeout_usec, error_ptr);
if (status != eConnectionStatusSuccess)
return 0;
Error error;
size_t bytes_read = dst_len;
error = m_read_sp->Read(dst, bytes_read);
if (log)
{
log->Printf("%p ConnectionFileDescriptor::Read() fd = %" PRIu64 ", dst = %p, dst_len = %" PRIu64 ") => %" PRIu64 ", error = %s",
static_cast<void*>(this),
static_cast<uint64_t>(m_read_sp->GetWaitableHandle()),
static_cast<void*>(dst),
static_cast<uint64_t>(dst_len),
static_cast<uint64_t>(bytes_read),
error.AsCString());
}
if (bytes_read == 0)
{
error.Clear(); // End-of-file. Do not automatically close; pass along for the end-of-file handlers.
status = eConnectionStatusEndOfFile;
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
uint32_t error_value = error.GetError();
switch (error_value)
{
case EAGAIN: // The file was marked for non-blocking I/O, and no data were ready to be read.
if (m_read_sp->GetFdType() == IOObject::eFDTypeSocket)
status = eConnectionStatusTimedOut;
else
status = eConnectionStatusSuccess;
return 0;
case EFAULT: // Buf points outside the allocated address space.
case EINTR: // A read from a slow device was interrupted before any data arrived by the delivery of a signal.
case EINVAL: // The pointer associated with fildes was negative.
case EIO: // An I/O error occurred while reading from the file system.
// The process group is orphaned.
// The file is a regular file, nbyte is greater than 0,
// the starting position is before the end-of-file, and
// the starting position is greater than or equal to the
// offset maximum established for the open file
// descriptor associated with fildes.
case EISDIR: // An attempt is made to read a directory.
case ENOBUFS: // An attempt to allocate a memory buffer fails.
case ENOMEM: // Insufficient memory is available.
status = eConnectionStatusError;
break; // Break to close....
case ENOENT: // no such file or directory
case EBADF: // fildes is not a valid file or socket descriptor open for reading.
case ENXIO: // An action is requested of a device that does not exist..
// A requested action cannot be performed by the device.
case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket.
case ENOTCONN: // A read is attempted on an unconnected socket.
status = eConnectionStatusLostConnection;
break; // Break to close....
case ETIMEDOUT: // A transmission timeout occurs during a read attempt on a socket.
status = eConnectionStatusTimedOut;
return 0;
default:
if (log)
log->Printf("%p ConnectionFileDescriptor::Read (), unexpected error: %s",
static_cast<void*>(this), strerror(error_value));
status = eConnectionStatusError;
break; // Break to close....
}
return 0;
}
return bytes_read;
}
size_t
ConnectionFileDescriptor::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
{
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Write (src = %p, src_len = %" PRIu64 ")",
static_cast<void*>(this), static_cast<const void*>(src),
static_cast<uint64_t>(src_len));
if (!IsConnected ())
{
if (error_ptr)
error_ptr->SetErrorString("not connected");
status = eConnectionStatusNoConnection;
return 0;
}
Error error;
size_t bytes_sent = src_len;
error = m_write_sp->Write(src, bytes_sent);
if (log)
{
log->Printf ("%p ConnectionFileDescriptor::Write(fd = %" PRIu64 ", src = %p, src_len = %" PRIu64 ") => %" PRIu64 " (error = %s)",
static_cast<void*>(this),
static_cast<uint64_t>(m_write_sp->GetWaitableHandle()),
static_cast<const void*>(src),
static_cast<uint64_t>(src_len),
static_cast<uint64_t>(bytes_sent),
error.AsCString());
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
switch (error.GetError())
{
case EAGAIN:
case EINTR:
status = eConnectionStatusSuccess;
return 0;
case ECONNRESET:// The connection is closed by the peer during a read attempt on a socket.
case ENOTCONN: // A read is attempted on an unconnected socket.
status = eConnectionStatusLostConnection;
break; // Break to close....
default:
status = eConnectionStatusError;
break; // Break to close....
}
return 0;
}
status = eConnectionStatusSuccess;
return bytes_sent;
}
// This ConnectionFileDescriptor::BytesAvailable() uses select().
//
// PROS:
// - select is consistent across most unix platforms
// - The Apple specific version allows for unlimited fds in the fd_sets by
// setting the _DARWIN_UNLIMITED_SELECT define prior to including the
// required header files.
// CONS:
// - on non-Apple platforms, only supports file descriptors up to FD_SETSIZE.
// This implementation will assert if it runs into that hard limit to let
// users know that another ConnectionFileDescriptor::BytesAvailable() should
// be used or a new version of ConnectionFileDescriptor::BytesAvailable()
// should be written for the system that is running into the limitations.
#if defined(__APPLE__)
#define FD_SET_DATA(fds) fds.data()
#else
#define FD_SET_DATA(fds) &fds
#endif
ConnectionStatus
ConnectionFileDescriptor::BytesAvailable (uint32_t timeout_usec, Error *error_ptr)
{
// Don't need to take the mutex here separately since we are only called from Read. If we
// ever get used more generally we will need to lock here as well.
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)",
static_cast<void*>(this), timeout_usec);
struct timeval *tv_ptr;
struct timeval tv;
if (timeout_usec == UINT32_MAX)
{
// Inifinite wait...
tv_ptr = nullptr;
}
else
{
TimeValue time_value;
time_value.OffsetWithMicroSeconds (timeout_usec);
tv.tv_sec = time_value.seconds();
tv.tv_usec = time_value.microseconds();
tv_ptr = &tv;
}
// Make a copy of the file descriptors to make sure we don't
// have another thread change these values out from under us
// and cause problems in the loop below where like in FS_SET()
const IOObject::WaitableHandle handle = m_read_sp->GetWaitableHandle();
const int pipe_fd = m_pipe.GetReadFileDescriptor();
if (handle != IOObject::kInvalidHandleValue)
{
#if defined(_MSC_VER)
// select() won't accept pipes on Windows. The entire Windows codepath needs to be
// converted over to using WaitForMultipleObjects and event HANDLEs, but for now at least
// this will allow ::select() to not return an error.
const bool have_pipe_fd = false;
#else
const bool have_pipe_fd = pipe_fd >= 0;
#if !defined(__APPLE__)
assert (handle < FD_SETSIZE);
if (have_pipe_fd)
assert (pipe_fd < FD_SETSIZE);
#endif
#endif
while (handle == m_read_sp->GetWaitableHandle())
{
const int nfds = std::max<int>(handle, pipe_fd) + 1;
#if defined(__APPLE__)
llvm::SmallVector<fd_set, 1> read_fds;
read_fds.resize((nfds/FD_SETSIZE) + 1);
for (size_t i=0; i<read_fds.size(); ++i)
FD_ZERO (&read_fds[i]);
// FD_SET doesn't bounds check, it just happily walks off the end
// but we have taken care of making the extra storage with our
// SmallVector of fd_set objects
#else
fd_set read_fds;
FD_ZERO (&read_fds);
#endif
FD_SET (handle, FD_SET_DATA(read_fds));
if (have_pipe_fd)
FD_SET (pipe_fd, FD_SET_DATA(read_fds));
Error error;
if (log)
{
if (have_pipe_fd)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p)...",
static_cast<void*>(this), nfds, handle, pipe_fd,
static_cast<void*>(tv_ptr));
else
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p)...",
static_cast<void*>(this), nfds, handle,
static_cast<void*>(tv_ptr));
}
const int num_set_fds = ::select (nfds, FD_SET_DATA(read_fds), NULL, NULL, tv_ptr);
if (num_set_fds < 0)
error.SetErrorToErrno();
else
error.Clear();
if (log)
{
if (have_pipe_fd)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i, %i}, NULL, NULL, timeout=%p) => %d, error = %s",
static_cast<void*>(this), nfds, handle,
pipe_fd, static_cast<void*>(tv_ptr), num_set_fds,
error.AsCString());
else
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds=%i, fds={%i}, NULL, NULL, timeout=%p) => %d, error = %s",
static_cast<void*>(this), nfds, handle,
static_cast<void*>(tv_ptr), num_set_fds,
error.AsCString());
}
if (error_ptr)
*error_ptr = error;
if (error.Fail())
{
switch (error.GetError())
{
case EBADF: // One of the descriptor sets specified an invalid descriptor.
return eConnectionStatusLostConnection;
case EINVAL: // The specified time limit is invalid. One of its components is negative or too large.
default: // Other unknown error
return eConnectionStatusError;
case EAGAIN: // The kernel was (perhaps temporarily) unable to
// allocate the requested number of file descriptors,
// or we have non-blocking IO
case EINTR: // A signal was delivered before the time limit
// expired and before any of the selected events
// occurred.
break; // Lets keep reading to until we timeout
}
}
else if (num_set_fds == 0)
{
return eConnectionStatusTimedOut;
}
else if (num_set_fds > 0)
{
if (FD_ISSET(handle, FD_SET_DATA(read_fds)))
return eConnectionStatusSuccess;
if (have_pipe_fd && FD_ISSET(pipe_fd, FD_SET_DATA(read_fds)))
{
// We got a command to exit. Read the data from that pipe:
char buffer[16];
ssize_t bytes_read;
do
{
bytes_read = ::read (pipe_fd, buffer, sizeof(buffer));
} while (bytes_read < 0 && errno == EINTR);
switch (buffer[0])
{
case 'q':
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.",
static_cast<void*>(this),
static_cast<int>(bytes_read), buffer);
return eConnectionStatusEndOfFile;
case 'i':
// Interrupt the current read
return eConnectionStatusInterrupted;
}
}
}
}
}
if (error_ptr)
error_ptr->SetErrorString("not connected");
return eConnectionStatusLostConnection;
}
ConnectionStatus
ConnectionFileDescriptor::NamedSocketAccept (const char *socket_name, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::UnixDomainAccept(socket_name, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::NamedSocketConnect (const char *socket_name, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::UnixDomainConnect(socket_name, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::SocketListen(const char *s, Error *error_ptr)
{
m_port_predicate.SetValue(0, eBroadcastNever);
Socket* socket = nullptr;
m_waiting_for_accept = true;
Error error = Socket::TcpListen(s, socket, &m_port_predicate);
if (error_ptr)
*error_ptr = error;
if (error.Fail())
return eConnectionStatusError;
std::unique_ptr<Socket> listening_socket_up;
listening_socket_up.reset(socket);
socket = nullptr;
error = listening_socket_up->BlockingAccept(s, socket);
listening_socket_up.reset();
if (error_ptr)
*error_ptr = error;
if (error.Fail())
return eConnectionStatusError;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::ConnectTCP(const char *s, Error *error_ptr)
{
Socket* socket = nullptr;
Error error = Socket::TcpConnect(s, socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(socket);
m_read_sp = m_write_sp;
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
ConnectionStatus
ConnectionFileDescriptor::ConnectUDP(const char *s, Error *error_ptr)
{
Socket* send_socket = nullptr;
Socket* recv_socket = nullptr;
Error error = Socket::UdpConnect(s, send_socket, recv_socket);
if (error_ptr)
*error_ptr = error;
m_write_sp.reset(send_socket);
m_read_sp.reset(recv_socket);
return (error.Success()) ? eConnectionStatusSuccess : eConnectionStatusError;
}
uint16_t ConnectionFileDescriptor::GetListeningPort(uint32_t timeout_sec)
{
uint16_t bound_port = 0;
if (timeout_sec == UINT32_MAX)
m_port_predicate.WaitForValueNotEqualTo (0, bound_port);
else
{
TimeValue timeout = TimeValue::Now();
timeout.OffsetWithSeconds(timeout_sec);
m_port_predicate.WaitForValueNotEqualTo (0, bound_port, &timeout);
}
return bound_port;
}

source/Interpreter/ScriptInterpreterPython.cpp

Context not available.
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/WatchpointOptions.h" #include "lldb/Breakpoint/WatchpointOptions.h"
#include "lldb/Core/Communication.h" #include "lldb/Core/Communication.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Timer.h" #include "lldb/Core/Timer.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/Pipe.h" #include "lldb/Host/Pipe.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
// Project includes // Project includes
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Error.h" #include "lldb/Core/Error.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
Context not available.
#include "lldb/Core/ModuleList.h" #include "lldb/Core/ModuleList.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Target/Process.h" #include "lldb/Target/Process.h"
Context not available.

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/UUID.h" #include "lldb/Core/UUID.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/Symbols.h" #include "lldb/Host/Symbols.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
Context not available.

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

Context not available.
// C++ Includes // C++ Includes
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Host/FileSystem.h" #include "lldb/Host/FileSystem.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
Context not available.

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

Context not available.
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamGDBRemote.h" #include "lldb/Core/StreamGDBRemote.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
Context not available.

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

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "llvm/ADT/Triple.h" #include "llvm/ADT/Triple.h"
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamString.h" #include "lldb/Core/StreamString.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Debug.h" #include "lldb/Host/Debug.h"
#include "lldb/Host/Endian.h" #include "lldb/Host/Endian.h"
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
Context not available.

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

Context not available.
#include "lldb/Interpreter/Args.h" #include "lldb/Interpreter/Args.h"
#include "lldb/Core/ArchSpec.h" #include "lldb/Core/ArchSpec.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/ConnectionFileDescriptor.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/FileSpec.h" #include "lldb/Host/FileSpec.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
Context not available.

source/Target/Process.cpp

Context not available.
#include "lldb/Breakpoint/StoppointCallbackContext.h" #include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Event.h" #include "lldb/Core/Event.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h" #include "lldb/Core/Log.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/State.h" #include "lldb/Core/State.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Expression/ClangUserExpression.h" #include "lldb/Expression/ClangUserExpression.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/Host.h" #include "lldb/Host/Host.h"
#include "lldb/Host/HostInfo.h" #include "lldb/Host/HostInfo.h"
#include "lldb/Host/Pipe.h" #include "lldb/Host/Pipe.h"
#include "lldb/Host/Terminal.h" #include "lldb/Host/Terminal.h"
#include "lldb/Host/ThreadLauncher.h" #include "lldb/Host/ThreadLauncher.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/ABI.h" #include "lldb/Target/ABI.h"
#include "lldb/Target/DynamicLoader.h" #include "lldb/Target/DynamicLoader.h"
#include "lldb/Target/JITLoader.h" #include "lldb/Target/JITLoader.h"
Context not available.

tools/lldb-gdbserver/lldb-gdbserver.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/lldb-private-log.h" #include "lldb/lldb-private-log.h"
#include "lldb/Core/Error.h" #include "lldb/Core/Error.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/ConnectionMachPort.h" #include "lldb/Core/ConnectionMachPort.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/PluginManager.h" #include "lldb/Core/PluginManager.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/HostThread.h" #include "lldb/Host/HostThread.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Host/Socket.h" #include "lldb/Host/Socket.h"
Context not available.

tools/lldb-platform/lldb-platform.cpp

Context not available.
// Other libraries and framework includes // Other libraries and framework includes
#include "lldb/lldb-private-log.h" #include "lldb/lldb-private-log.h"
#include "lldb/Core/Error.h" #include "lldb/Core/Error.h"
#include "lldb/Core/ConnectionFileDescriptor.h"
#include "lldb/Core/ConnectionMachPort.h" #include "lldb/Core/ConnectionMachPort.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/StreamFile.h" #include "lldb/Core/StreamFile.h"
#include "lldb/Host/ConnectionFileDescriptor.h"
#include "lldb/Host/HostGetOpt.h" #include "lldb/Host/HostGetOpt.h"
#include "lldb/Host/OptionParser.h" #include "lldb/Host/OptionParser.h"
#include "lldb/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandInterpreter.h"
Context not available.
source/API/SBCommunication.cpp