Error
File::Close ()
{
Error error;
if (StreamIsValid() && m_own_stream)
{
if (::fclose (m_stream) == EOF)
error.SetErrorToErrno();
}
if (DescriptorIsValid() && m_own_descriptor)
{
if (::close (m_descriptor) != 0)
error.SetErrorToErrno();
}
m_descriptor = kInvalidDescriptor;
m_stream = kInvalidStream;
m_options = 0;
m_own_stream = false;
m_own_descriptor = false;
m_is_interactive = eLazyBoolCalculate;
m_is_real_terminal = eLazyBoolCalculate;
return error;
}
Error
File::Flush ()
{
Error error;
if (StreamIsValid())
{
if (::fflush (m_stream) == EOF)
error.SetErrorToErrno();
}
else if (!DescriptorIsValid())
{
error.SetErrorString("invalid file handle");
}
return error;
}
Error
File::Sync ()
{
Error error;
if (DescriptorIsValid())
{
if (::fsync (m_descriptor) == -1)
error.SetErrorToErrno();
}
else
{
error.SetErrorString("invalid file handle");
}
return error;
}
static size_t
DoWriteMemory(lldb::pid_t pid, lldb::addr_t vm_addr, const void *buf,
size_t size, Error &error)
{
struct ptrace_io_desc pi_desc;
pi_desc.piod_op = PIOD_WRITE_D;
pi_desc.piod_offs = (void *)vm_addr;
pi_desc.piod_addr = (void *)buf;
pi_desc.piod_len = size;
if (PTRACE(PT_IO, pid, (caddr_t)&pi_desc, 0) < 0)
error.SetErrorToErrno();
return pi_desc.piod_len;
}
Error
File::Write (const void *buf, size_t &num_bytes, off_t &offset)
{
Error error;
int fd = GetDescriptor();
if (fd != kInvalidDescriptor)
{
#ifndef _WIN32
ssize_t bytes_written = -1;
do
{
bytes_written = ::pwrite (m_descriptor, buf, num_bytes, offset);
} while (bytes_written < 0 && errno == EINTR);
if (bytes_written < 0)
{
num_bytes = 0;
error.SetErrorToErrno();
}
else
{
offset += bytes_written;
num_bytes = bytes_written;
}
#else
/* FIXME:
TODO: Make sure num_bytes does not overflow.
OVERLAPPED overlapped = {};
overlapped.Offset = static_cast<DWORD>(off);
overlapped.OffsetHigh = static_cast<DWORD>(off >> 32);
WriteFile((HANDLE)_get_osfhandle(fd), to, reading, &ret, &overlapped)
*/
long cur = ::lseek(m_descriptor, 0, SEEK_CUR);
SeekFromStart(offset);
error = Write(buf, num_bytes);
if (!error.Fail()) {
offset = ::lseek(m_descriptor, 0, SEEK_CUR);
SeekFromStart(cur);
}
#endif
}
else
{
num_bytes = 0;
error.SetErrorString("invalid file handle");
}
return error;
}
Error
File::SeekFromEnd (off_t& offset)
{
Error error;
if (DescriptorIsValid())
{
offset = ::lseek (m_descriptor, offset, SEEK_END);
if (offset == -1)
error.SetErrorToErrno();
}
else
{
error.SetErrorString("invalid file handle");
}
return error;
}
uint32_t
File::GetPermissions(const FileSpec &file_spec, Error &error)
{
if (file_spec)
{
struct stat file_stats;
if (::stat(file_spec.GetCString(), &file_stats) == -1)
error.SetErrorToErrno();
else
{
error.Clear();
return file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
}
else
error.SetErrorString ("empty file spec");
return 0;
}
Error PipePosix::OpenAsReader(llvm::StringRef name,
bool child_process_inherit) {
if (CanRead() || CanWrite())
return Error("Pipe is already opened");
int flags = O_RDONLY | O_NONBLOCK;
if (!child_process_inherit)
flags |= O_CLOEXEC;
Error error;
int fd = ::open(name.data(), flags);
if (fd != -1)
m_fds[READ] = fd;
else
error.SetErrorToErrno();
return error;
}
Error
File::Write (const void *buf, size_t &num_bytes)
{
Error error;
ssize_t bytes_written = -1;
if (DescriptorIsValid())
{
do
{
bytes_written = ::write (m_descriptor, buf, num_bytes);
} while (bytes_written < 0 && errno == EINTR);
if (bytes_written == -1)
{
error.SetErrorToErrno();
num_bytes = 0;
}
else
num_bytes = bytes_written;
}
else if (StreamIsValid())
{
bytes_written = ::fwrite (buf, 1, num_bytes, m_stream);
if (bytes_written == 0)
{
if (::feof(m_stream))
error.SetErrorString ("feof");
else if (::ferror (m_stream))
error.SetErrorString ("ferror");
num_bytes = 0;
}
else
num_bytes = bytes_written;
}
else
{
num_bytes = 0;
error.SetErrorString("invalid file handle");
}
return error;
}
Error
File::Write (const void *buf, size_t &num_bytes, off_t &offset)
{
Error error;
int fd = GetDescriptor();
if (fd != kInvalidDescriptor)
{
#ifndef _WIN32
ssize_t bytes_written = -1;
do
{
bytes_written = ::pwrite (m_descriptor, buf, num_bytes, offset);
} while (bytes_written < 0 && errno == EINTR);
if (bytes_written < 0)
{
num_bytes = 0;
error.SetErrorToErrno();
}
else
{
offset += bytes_written;
num_bytes = bytes_written;
}
#else
long cur = ::lseek(m_descriptor, 0, SEEK_CUR);
error = Write(buf, num_bytes);
long after = ::lseek(m_descriptor, 0, SEEK_CUR);
if (!error.Fail())
SeekFromStart(cur);
ssize_t bytes_written = after - cur;
offset = after;
#endif
}
else
{
num_bytes = 0;
error.SetErrorString("invalid file handle");
}
return error;
}
Error
ProcessFreeBSD::DoHalt(bool &caused_stop)
{
Error error;
if (IsStopped())
{
caused_stop = false;
}
else if (kill(GetID(), SIGSTOP))
{
caused_stop = false;
error.SetErrorToErrno();
}
else
{
caused_stop = true;
}
return error;
}
Error
ProcessPOSIX::DoDestroy()
{
Error error;
if (!HasExited())
{
assert(m_monitor);
m_exit_now = true;
if (!m_monitor->Kill())
{
error.SetErrorToErrno();
return error;
}
SetPrivateState(eStateExited);
}
return error;
}
Error ProcessFreeBSD::DoDestroy() {
Error error;
if (!HasExited()) {
assert(m_monitor);
m_exit_now = true;
if (GetID() == LLDB_INVALID_PROCESS_ID) {
error.SetErrorString("invalid process id");
return error;
}
if (!m_monitor->Kill()) {
error.SetErrorToErrno();
return error;
}
SetPrivateState(eStateExited);
}
return error;
}
Error
File::Sync ()
{
Error error;
if (DescriptorIsValid())
{
int err = 0;
do
{
err = ::fsync (m_descriptor);
} while (err == -1 && errno == EINTR);
if (err == -1)
error.SetErrorToErrno();
}
else
{
error.SetErrorString("invalid file handle");
}
return error;
}
Error
File::Flush ()
{
Error error;
if (StreamIsValid())
{
int err = 0;
do
{
err = ::fflush (m_stream);
} while (err == EOF && errno == EINTR);
if (err == EOF)
error.SetErrorToErrno();
}
else if (!DescriptorIsValid())
{
error.SetErrorString("invalid file handle");
}
return error;
}
uint32_t
File::GetPermissions(Error &error) const
{
int fd = GetDescriptor();
if (fd != kInvalidDescriptor)
{
struct stat file_stats;
if (::fstat (fd, &file_stats) == -1)
error.SetErrorToErrno();
else
{
error.Clear();
return file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
}
else
{
error.SetErrorString ("invalid file descriptor");
}
return 0;
}
Error
File::Read (void *buf, size_t &num_bytes, off_t &offset)
{
#ifndef _WIN32
Error error;
int fd = GetDescriptor();
if (fd != kInvalidDescriptor)
{
ssize_t bytes_read = -1;
do
{
bytes_read = ::pread (fd, buf, num_bytes, offset);
} while (bytes_read < 0 && errno == EINTR);
if (bytes_read < 0)
{
num_bytes = 0;
error.SetErrorToErrno();
}
else
{
offset += bytes_read;
num_bytes = bytes_read;
}
}
else
{
num_bytes = 0;
error.SetErrorString("invalid file handle");
}
return error;
#else
long cur = ::lseek(m_descriptor, 0, SEEK_CUR);
SeekFromStart(offset);
Error error = Read(buf, num_bytes);
if (!error.Fail())
SeekFromStart(cur);
return error;
#endif
}
ModuleLock::ModuleLock(const FileSpec &root_dir_spec, const UUID &uuid,
Error &error) {
const auto lock_dir_spec = JoinPath(root_dir_spec, kLockDirName);
error = MakeDirectory(lock_dir_spec);
if (error.Fail())
return;
m_file_spec = JoinPath(lock_dir_spec, uuid.GetAsString().c_str());
m_file.Open(m_file_spec.GetCString(), File::eOpenOptionWrite |
File::eOpenOptionCanCreate |
File::eOpenOptionCloseOnExec);
if (!m_file) {
error.SetErrorToErrno();
return;
}
m_lock.reset(new lldb_private::LockFile(m_file.GetDescriptor()));
error = m_lock->WriteLock(0, 1);
if (error.Fail())
error.SetErrorStringWithFormat("Failed to lock file: %s",
error.AsCString());
}
Error
ProcessPOSIX::DoDestroy()
{
Error error;
if (!HasExited())
{
// Drive the exit event to completion (do not keep the inferior in
// limbo).
m_exit_now = true;
if ((m_monitor == NULL || kill(m_monitor->GetPID(), SIGKILL)) && error.Success())
{
error.SetErrorToErrno();
return error;
}
SetPrivateState(eStateExited);
}
return error;
}
uint32_t
File::GetPermissions (const char *path, Error &error)
{
if (path && path[0])
{
struct stat file_stats;
if (::stat (path, &file_stats) == -1)
error.SetErrorToErrno();
else
{
error.Clear();
return file_stats.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
}
}
else
{
if (path)
error.SetErrorString ("invalid path");
else
error.SetErrorString ("empty path");
}
return 0;
}
Error
FileSystem::GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
{
Error error;
// Beware that Windows's permission model is different from Unix's, and it's
// not clear if this API is supposed to check ACLs. To match the caller's
// expectations as closely as possible, we'll use Microsoft's _stat, which
// attempts to emulate POSIX stat. This should be good enough for basic
// checks like FileSpec::Readable.
struct _stat file_stats;
if (::_stat(file_spec.GetCString(), &file_stats) == 0)
{
// The owner permission bits in "st_mode" currently match the definitions
// for the owner file mode bits.
file_permissions = file_stats.st_mode & (_S_IREAD | _S_IWRITE | _S_IEXEC);
}
else
{
error.SetErrorToErrno();
}
return error;
}
Error
File::Read (void *buf, size_t &num_bytes)
{
Error error;
if (DescriptorIsValid())
{
ssize_t bytes_read = ::read (m_descriptor, buf, num_bytes);
if (bytes_read == -1)
{
error.SetErrorToErrno();
num_bytes = 0;
}
else
num_bytes = bytes_read;
}
else if (StreamIsValid())
{
size_t bytes_read = ::fread (buf, 1, num_bytes, m_stream);
if (bytes_read == 0)
{
if (::feof(m_stream))
error.SetErrorString ("feof");
else if (::ferror (m_stream))
error.SetErrorString ("ferror");
num_bytes = 0;
}
else
num_bytes = bytes_read;
}
else
{
num_bytes = 0;
error.SetErrorString("invalid file handle");
}
return error;
}
Error
File::Duplicate (const File &rhs)
{
Error error;
if (IsValid ())
Close();
if (rhs.DescriptorIsValid())
{
m_descriptor = ::fcntl(rhs.GetDescriptor(), F_DUPFD);
if (!DescriptorIsValid())
error.SetErrorToErrno();
else
{
m_options = rhs.m_options;
m_owned = true;
}
}
else
{
error.SetErrorString ("invalid file to duplicate");
}
return error;
}
Error
NativeThreadLinux::RequestStop ()
{
Log* log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
NativeProcessLinux &process = GetProcess();
lldb::pid_t pid = process.GetID();
lldb::tid_t tid = GetID();
if (log)
log->Printf ("NativeThreadLinux::%s requesting thread stop(pid: %" PRIu64 ", tid: %" PRIu64 ")", __FUNCTION__, pid, tid);
Error err;
errno = 0;
if (::tgkill (pid, tid, SIGSTOP) != 0)
{
err.SetErrorToErrno ();
if (log)
log->Printf ("NativeThreadLinux::%s tgkill(%" PRIu64 ", %" PRIu64 ", SIGSTOP) failed: %s", __FUNCTION__, pid, tid, err.AsCString ());
}
return err;
}
//----------------------------------------------------------------------
// The file descriptor FD is assumed to already be opened as read only
// and the STAT structure is assumed to a valid pointer and already
// containing valid data from a call to stat().
//
// Memory map FILE_LENGTH bytes in FILE starting FILE_OFFSET bytes into
// the file. If FILE_LENGTH is set to SIZE_MAX, then map as many bytes
// as possible.
//
// RETURNS
// Number of bytes mapped starting from the requested offset.
//----------------------------------------------------------------------
size_t
DataBufferMemoryMap::MemoryMapFromFileDescriptor (int fd,
off_t offset,
size_t length,
bool writeable,
bool fd_is_file)
{
Clear();
if (fd >= 0)
{
struct stat stat;
if (::fstat(fd, &stat) == 0)
{
if (S_ISREG(stat.st_mode) && (stat.st_size > offset))
{
const size_t max_bytes_available = stat.st_size - offset;
if (length == SIZE_MAX)
{
length = max_bytes_available;
}
else if (length > max_bytes_available)
{
// Cap the length if too much data was requested
length = max_bytes_available;
}
if (length > 0)
{
int prot = PROT_READ;
if (writeable)
prot |= PROT_WRITE;
int flags = MAP_PRIVATE;
if (fd_is_file)
flags |= MAP_FILE;
m_mmap_addr = (uint8_t *)::mmap(NULL, length, prot, flags, fd, offset);
if (m_mmap_addr == (void*)-1)
{
Error error;
error.SetErrorToErrno ();
if (error.GetError() == EINVAL)
{
// We may still have a shot at memory mapping if we align things correctly
size_t page_offset = offset % Host::GetPageSize();
if (page_offset != 0)
{
m_mmap_addr = (uint8_t *)::mmap(NULL, length + page_offset, prot, flags, fd, offset - page_offset);
if (m_mmap_addr == (void*)-1)
{
// Failed to map file
m_mmap_addr = NULL;
}
else if (m_mmap_addr != NULL)
{
// We recovered and were able to memory map
// after we aligned things to page boundaries
// Save the actual mmap'ed size
m_mmap_size = length + page_offset;
// Our data is at an offset into the the mapped data
m_data = m_mmap_addr + page_offset;
// Our pretend size is the size that was requestd
m_size = length;
}
}
}
if (error.GetError() == ENOMEM)
{
error.SetErrorStringWithFormat("could not allocate %lld bytes of memory to mmap in file", (uint64_t) length);
}
}
else
{
// We were able to map the requested data in one chunk
// where our mmap and actual data are the same.
m_mmap_size = length;
m_data = m_mmap_addr;
m_size = length;
}
}
}
}
}
return GetByteSize ();
}
Error
ProcessPOSIX::DoLaunch (Module *module,
ProcessLaunchInfo &launch_info)
{
Error error;
assert(m_monitor == NULL);
const char* working_dir = launch_info.GetWorkingDirectory();
if (working_dir) {
FileSpec WorkingDir(working_dir, true);
if (!WorkingDir || WorkingDir.GetFileType() != FileSpec::eFileTypeDirectory)
{
error.SetErrorStringWithFormat("No such file or directory: %s", working_dir);
return error;
}
}
SetPrivateState(eStateLaunching);
const lldb_private::FileAction *file_action;
// Default of NULL will mean to use existing open file descriptors
const char *stdin_path = NULL;
const char *stdout_path = NULL;
const char *stderr_path = NULL;
const char * dbg_pts_path = launch_info.GetPTY().GetSlaveName(NULL,0);
file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
stdin_path = GetFilePath(file_action, stdin_path, dbg_pts_path);
file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
stdout_path = GetFilePath(file_action, stdout_path, dbg_pts_path);
file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
stderr_path = GetFilePath(file_action, stderr_path, dbg_pts_path);
m_monitor = new ProcessMonitor (this,
module,
launch_info.GetArguments().GetConstArgumentVector(),
launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
stdin_path,
stdout_path,
stderr_path,
working_dir,
launch_info,
error);
m_module = module;
if (!error.Success())
return error;
int terminal = m_monitor->GetTerminalFD();
if (terminal >= 0) {
// The reader thread will close the file descriptor when done, so we pass it a copy.
int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
if (stdio == -1) {
error.SetErrorToErrno();
return error;
}
SetSTDIOFileDescriptor(stdio);
}
SetID(m_monitor->GetPID());
return error;
}
Error
ProcessFreeBSD::DoLaunch (Module *module,
ProcessLaunchInfo &launch_info)
{
Error error;
assert(m_monitor == NULL);
FileSpec working_dir = launch_info.GetWorkingDirectory();
if (working_dir &&
(!working_dir.ResolvePath() ||
working_dir.GetFileType() != FileSpec::eFileTypeDirectory))
{
error.SetErrorStringWithFormat("No such file or directory: %s",
working_dir.GetCString());
return error;
}
SetPrivateState(eStateLaunching);
const lldb_private::FileAction *file_action;
// Default of empty will mean to use existing open file descriptors
FileSpec stdin_file_spec{};
FileSpec stdout_file_spec{};
FileSpec stderr_file_spec{};
const FileSpec dbg_pts_file_spec{launch_info.GetPTY().GetSlaveName(NULL,0), false};
file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
stdin_file_spec = GetFileSpec(file_action, stdin_file_spec, dbg_pts_file_spec);
file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
stdout_file_spec = GetFileSpec(file_action, stdout_file_spec, dbg_pts_file_spec);
file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
stderr_file_spec = GetFileSpec(file_action, stderr_file_spec, dbg_pts_file_spec);
m_monitor = new ProcessMonitor(this,
module,
launch_info.GetArguments().GetConstArgumentVector(),
launch_info.GetEnvironmentEntries().GetConstArgumentVector(),
stdin_file_spec,
stdout_file_spec,
stderr_file_spec,
working_dir,
launch_info,
error);
m_module = module;
if (!error.Success())
return error;
int terminal = m_monitor->GetTerminalFD();
if (terminal >= 0) {
// The reader thread will close the file descriptor when done, so we pass it a copy.
int stdio = fcntl(terminal, F_DUPFD_CLOEXEC, 0);
if (stdio == -1) {
error.SetErrorToErrno();
return error;
}
SetSTDIOFileDescriptor(stdio);
}
SetID(m_monitor->GetPID());
return error;
}
size_t
ConnectionFileDescriptor::Read (void *dst,
size_t dst_len,
uint32_t timeout_usec,
ConnectionStatus &status,
Error *error_ptr)
{
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Read () ::read (fd = %i, dst = %p, dst_len = %llu)...",
this, m_fd_recv, dst, (uint64_t)dst_len);
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.",
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;
ssize_t bytes_read = 0;
status = BytesAvailable (timeout_usec, error_ptr);
if (status == eConnectionStatusSuccess)
{
do
{
bytes_read = ::read (m_fd_recv, dst, dst_len);
} while (bytes_read < 0 && errno == EINTR);
}
if (status != eConnectionStatusSuccess)
return 0;
Error error;
if (bytes_read == 0)
{
error.Clear(); // End-of-file. Do not automatically close; pass along for the end-of-file handlers.
status = eConnectionStatusEndOfFile;
}
else if (bytes_read < 0)
{
error.SetErrorToErrno();
}
else
{
error.Clear();
}
if (log)
log->Printf ("%p ConnectionFileDescriptor::Read () ::read (fd = %i, dst = %p, dst_len = %llu) => %lli, error = %s",
this,
m_fd_recv,
dst,
(uint64_t)dst_len,
(int64_t)bytes_read,
error.AsCString());
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_fd_recv_type == eFDTypeSocket || m_fd_recv_type == eFDTypeSocketUDP)
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;
}
//Disconnect (NULL);
return 0;
}
return bytes_read;
}
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.
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable (timeout_usec = %u)", this, timeout_usec);
struct timeval *tv_ptr;
struct timeval tv;
if (timeout_usec == UINT32_MAX)
{
// Infinite wait...
tv_ptr = NULL;
}
else
{
TimeValue time_value;
time_value.OffsetWithMicroSeconds (timeout_usec);
tv = time_value.GetAsTimeVal();
tv_ptr = &tv;
}
while (m_fd_recv >= 0)
{
fd_set read_fds;
FD_ZERO (&read_fds);
FD_SET (m_fd_recv, &read_fds);
if (m_pipe_read != -1)
FD_SET (m_pipe_read, &read_fds);
int nfds = std::max<int>(m_fd_recv, m_pipe_read) + 1;
Error error;
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds = %i, fd = %i, NULL, NULL, timeout = %p)...",
this, nfds, m_fd_recv, tv_ptr);
const int num_set_fds = ::select (nfds, &read_fds, NULL, NULL, tv_ptr);
if (num_set_fds < 0)
error.SetErrorToErrno();
else
error.Clear();
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() ::select (nfds = %i, fd = %i, NULL, NULL, timeout = %p) => %d, error = %s",
this, nfds, m_fd_recv, 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 (m_pipe_read != -1 && FD_ISSET(m_pipe_read, &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 (m_pipe_read, buffer, sizeof(buffer));
} while (bytes_read < 0 && errno == EINTR);
assert (bytes_read == 1 && buffer[0] == 'q');
if (log)
log->Printf("%p ConnectionFileDescriptor::BytesAvailable() got data: %*s from the command channel.",
this, (int) bytes_read, buffer);
return eConnectionStatusEndOfFile;
}
else
return eConnectionStatusSuccess;
}
}
if (error_ptr)
error_ptr->SetErrorString("not connected");
return eConnectionStatusLostConnection;
}
size_t
ConnectionFileDescriptor::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
{
LogSP log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_CONNECTION));
if (log)
log->Printf ("%p ConnectionFileDescriptor::Write (src = %p, src_len = %llu)", this, src, (uint64_t)src_len);
if (!IsConnected ())
{
if (error_ptr)
error_ptr->SetErrorString("not connected");
status = eConnectionStatusNoConnection;
return 0;
}
Error error;
ssize_t bytes_sent = 0;
switch (m_fd_send_type)
{
case eFDTypeFile: // Other FD requireing read/write
do
{
bytes_sent = ::write (m_fd_send, src, src_len);
} while (bytes_sent < 0 && errno == EINTR);
break;
case eFDTypeSocket: // Socket requiring send/recv
do
{
bytes_sent = ::send (m_fd_send, src, src_len, 0);
} while (bytes_sent < 0 && errno == EINTR);
break;
case eFDTypeSocketUDP: // Unconnected UDP socket requiring sendto/recvfrom
assert (m_udp_send_sockaddr.GetFamily() != 0);
do
{
bytes_sent = ::sendto (m_fd_send,
src,
src_len,
0,
m_udp_send_sockaddr,
m_udp_send_sockaddr.GetLength());
} while (bytes_sent < 0 && errno == EINTR);
break;
}
if (bytes_sent < 0)
error.SetErrorToErrno ();
else
error.Clear ();
if (log)
{
switch (m_fd_send_type)
{
case eFDTypeFile: // Other FD requireing read/write
log->Printf ("%p ConnectionFileDescriptor::Write() ::write (fd = %i, src = %p, src_len = %llu) => %lli (error = %s)",
this,
m_fd_send,
src,
(uint64_t)src_len,
(int64_t)bytes_sent,
error.AsCString());
break;
case eFDTypeSocket: // Socket requiring send/recv
log->Printf ("%p ConnectionFileDescriptor::Write() ::send (socket = %i, src = %p, src_len = %llu, flags = 0) => %lli (error = %s)",
this,
m_fd_send,
src,
(uint64_t)src_len,
(int64_t)bytes_sent,
error.AsCString());
break;
case eFDTypeSocketUDP: // Unconnected UDP socket requiring sendto/recvfrom
log->Printf ("%p ConnectionFileDescriptor::Write() ::sendto (socket = %i, src = %p, src_len = %llu, flags = 0) => %lli (error = %s)",
this,
m_fd_send,
src,
(uint64_t)src_len,
(int64_t)bytes_sent,
error.AsCString());
break;
}
}
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;
}
