forked from OSchip/llvm-project
365 lines
11 KiB
C++
365 lines
11 KiB
C++
//===-- Communication.cpp ---------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/lldb-private-log.h"
|
|
#include "lldb/Core/Communication.h"
|
|
#include "lldb/Core/Connection.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/Timer.h"
|
|
#include "lldb/Core/Event.h"
|
|
#include <string.h>
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// Constructor
|
|
//----------------------------------------------------------------------
|
|
Communication::Communication(const char *name) :
|
|
Broadcaster (name),
|
|
m_connection_ap (),
|
|
m_read_thread (LLDB_INVALID_HOST_THREAD),
|
|
m_read_thread_enabled (false),
|
|
m_bytes(),
|
|
m_bytes_mutex (Mutex::eMutexTypeRecursive),
|
|
m_callback (NULL),
|
|
m_callback_baton (NULL)
|
|
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::Communication (name = %s)",
|
|
this, name);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
Communication::~Communication()
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::~Communication (name = %s)",
|
|
this, m_broadcaster_name.AsCString(""));
|
|
Clear();
|
|
}
|
|
|
|
void
|
|
Communication::Clear()
|
|
{
|
|
StopReadThread (NULL);
|
|
Disconnect (NULL);
|
|
}
|
|
|
|
ConnectionStatus
|
|
Communication::BytesAvailable (uint32_t timeout_usec, Error *error_ptr)
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::BytesAvailable (timeout_usec = %u)", this, timeout_usec);
|
|
|
|
if (m_connection_ap.get())
|
|
return m_connection_ap->BytesAvailable (timeout_usec, error_ptr);
|
|
if (error_ptr)
|
|
error_ptr->SetErrorString("Invalid connection.");
|
|
return eConnectionStatusNoConnection;
|
|
}
|
|
|
|
ConnectionStatus
|
|
Communication::Connect (const char *url, Error *error_ptr)
|
|
{
|
|
Clear();
|
|
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Connect (url = %s)", this, url);
|
|
|
|
if (m_connection_ap.get())
|
|
return m_connection_ap->Connect (url, error_ptr);
|
|
if (error_ptr)
|
|
error_ptr->SetErrorString("Invalid connection.");
|
|
return eConnectionStatusNoConnection;
|
|
}
|
|
|
|
ConnectionStatus
|
|
Communication::Disconnect (Error *error_ptr)
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Disconnect ()", this);
|
|
|
|
if (m_connection_ap.get())
|
|
{
|
|
ConnectionStatus status = m_connection_ap->Disconnect (error_ptr);
|
|
m_connection_ap.reset();
|
|
return status;
|
|
}
|
|
return eConnectionStatusNoConnection;
|
|
}
|
|
|
|
bool
|
|
Communication::IsConnected () const
|
|
{
|
|
if (m_connection_ap.get())
|
|
return m_connection_ap->IsConnected ();
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Communication::HasConnection () const
|
|
{
|
|
return m_connection_ap.get() != NULL;
|
|
}
|
|
|
|
size_t
|
|
Communication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status, Error *error_ptr)
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::Write (dst = %p, dst_len = %zu, timeout_usec = %u) connection = %p",
|
|
this, dst, dst_len, timeout_usec, m_connection_ap.get());
|
|
|
|
if (m_read_thread != LLDB_INVALID_HOST_THREAD)
|
|
{
|
|
// We have a dedicated read thread that is getting data for us
|
|
size_t cached_bytes = GetCachedBytes (dst, dst_len);
|
|
if (cached_bytes > 0 || timeout_usec == 0)
|
|
{
|
|
status = eConnectionStatusSuccess;
|
|
return cached_bytes;
|
|
}
|
|
|
|
if (m_connection_ap.get() == NULL)
|
|
{
|
|
if (error_ptr)
|
|
error_ptr->SetErrorString("Invalid connection.");
|
|
status = eConnectionStatusNoConnection;
|
|
return 0;
|
|
}
|
|
// Set the timeout appropriately
|
|
TimeValue timeout_time;
|
|
if (timeout_usec != UINT32_MAX)
|
|
{
|
|
timeout_time = TimeValue::Now();
|
|
timeout_time.OffsetWithMicroSeconds (timeout_usec);
|
|
}
|
|
|
|
Listener listener ("Communication::Read");
|
|
listener.StartListeningForEvents (this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit);
|
|
EventSP event_sp;
|
|
while (listener.WaitForEvent (timeout_time.IsValid() ? &timeout_time : NULL, event_sp))
|
|
{
|
|
const uint32_t event_type = event_sp->GetType();
|
|
if (event_type & eBroadcastBitReadThreadGotBytes)
|
|
{
|
|
return GetCachedBytes (dst, dst_len);
|
|
}
|
|
|
|
if (event_type & eBroadcastBitReadThreadDidExit)
|
|
{
|
|
Disconnect (NULL);
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// We aren't using a read thread, just read the data synchronously in this
|
|
// thread.
|
|
if (m_connection_ap.get())
|
|
{
|
|
status = m_connection_ap->BytesAvailable (timeout_usec, error_ptr);
|
|
if (status == eConnectionStatusSuccess)
|
|
return m_connection_ap->Read (dst, dst_len, status, error_ptr);
|
|
}
|
|
|
|
if (error_ptr)
|
|
error_ptr->SetErrorString("Invalid connection.");
|
|
status = eConnectionStatusNoConnection;
|
|
return 0;
|
|
}
|
|
|
|
|
|
size_t
|
|
Communication::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::Write (src = %p, src_len = %zu) connection = %p",
|
|
this, src, src_len, m_connection_ap.get());
|
|
|
|
if (m_connection_ap.get())
|
|
return m_connection_ap->Write (src, src_len, status, error_ptr);
|
|
|
|
if (error_ptr)
|
|
error_ptr->SetErrorString("Invalid connection.");
|
|
status = eConnectionStatusNoConnection;
|
|
return 0;
|
|
}
|
|
|
|
|
|
bool
|
|
Communication::StartReadThread (Error *error_ptr)
|
|
{
|
|
if (m_read_thread != LLDB_INVALID_HOST_THREAD)
|
|
return true;
|
|
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::StartReadThread ()", this);
|
|
|
|
|
|
char thread_name[1024];
|
|
snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>", m_broadcaster_name.AsCString());
|
|
|
|
m_read_thread_enabled = true;
|
|
m_read_thread = Host::ThreadCreate (thread_name, Communication::ReadThread, this, error_ptr);
|
|
return m_read_thread != LLDB_INVALID_HOST_THREAD;
|
|
}
|
|
|
|
bool
|
|
Communication::StopReadThread (Error *error_ptr)
|
|
{
|
|
if (m_read_thread == LLDB_INVALID_HOST_THREAD)
|
|
return true;
|
|
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::StopReadThread ()", this);
|
|
|
|
m_read_thread_enabled = false;
|
|
|
|
BroadcastEvent (eBroadcastBitReadThreadShouldExit, NULL);
|
|
|
|
Host::ThreadCancel (m_read_thread, error_ptr);
|
|
|
|
return Host::ThreadJoin (m_read_thread, NULL, error_ptr);
|
|
}
|
|
|
|
|
|
size_t
|
|
Communication::GetCachedBytes (void *dst, size_t dst_len)
|
|
{
|
|
Mutex::Locker locker(m_bytes_mutex);
|
|
if (m_bytes.size() > 0)
|
|
{
|
|
// If DST is NULL and we have a thread, then return the number
|
|
// of bytes that are available so the caller can call again
|
|
if (dst == NULL)
|
|
return m_bytes.size();
|
|
|
|
const size_t len = std::min<size_t>(dst_len, m_bytes.size());
|
|
|
|
::memcpy (dst, m_bytes.c_str(), len);
|
|
m_bytes.erase(m_bytes.begin(), m_bytes.begin() + len);
|
|
|
|
return len;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
Communication::AppendBytesToCache (const uint8_t * bytes, size_t len, bool broadcast)
|
|
{
|
|
lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
|
|
"%p Communication::AppendBytesToCache (src = %p, src_len = %zu, broadcast = %i)",
|
|
this, bytes, len, broadcast);
|
|
if (bytes == NULL || len == 0)
|
|
return;
|
|
if (m_callback)
|
|
{
|
|
// If the user registered a callback, then call it and do not broadcast
|
|
m_callback (m_callback_baton, bytes, len);
|
|
}
|
|
else
|
|
{
|
|
Mutex::Locker locker(m_bytes_mutex);
|
|
m_bytes.append ((const char *)bytes, len);
|
|
if (broadcast)
|
|
BroadcastEventIfUnique (eBroadcastBitReadThreadGotBytes);
|
|
}
|
|
}
|
|
|
|
size_t
|
|
Communication::ReadFromConnection (void *dst, size_t dst_len, ConnectionStatus &status, Error *error_ptr)
|
|
{
|
|
if (m_connection_ap.get())
|
|
return m_connection_ap->Read (dst, dst_len, status, error_ptr);
|
|
return 0;
|
|
}
|
|
|
|
|
|
bool
|
|
Communication::ReadThreadIsRunning ()
|
|
{
|
|
return m_read_thread != LLDB_INVALID_HOST_THREAD;
|
|
}
|
|
|
|
void *
|
|
Communication::ReadThread (void *p)
|
|
{
|
|
Communication *comm = (Communication *)p;
|
|
|
|
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMUNICATION);
|
|
|
|
if (log)
|
|
log->Printf ("%p Communication::ReadThread () thread starting...", p);
|
|
|
|
uint8_t buf[1024];
|
|
|
|
Error error;
|
|
ConnectionStatus status = eConnectionStatusSuccess;
|
|
bool done = false;
|
|
while (!done && comm->m_read_thread_enabled)
|
|
{
|
|
status = comm->BytesAvailable (UINT32_MAX, &error);
|
|
|
|
if (status == eConnectionStatusSuccess)
|
|
{
|
|
size_t bytes_read = comm->ReadFromConnection (buf, sizeof(buf), status, &error);
|
|
if (bytes_read > 0)
|
|
comm->AppendBytesToCache (buf, bytes_read, true);
|
|
}
|
|
|
|
switch (status)
|
|
{
|
|
case eConnectionStatusSuccess:
|
|
break;
|
|
|
|
case eConnectionStatusNoConnection: // No connection
|
|
case eConnectionStatusLostConnection: // Lost connection while connected to a valid connection
|
|
done = true;
|
|
// Fall through...
|
|
default:
|
|
case eConnectionStatusError: // Check GetError() for details
|
|
case eConnectionStatusTimedOut: // Request timed out
|
|
error.LogIfError(log, "%p Communication::BytesAvailable () => status = %i", p, status);
|
|
break;
|
|
}
|
|
}
|
|
if (log)
|
|
log->Printf ("%p Communication::ReadThread () thread exiting...", p);
|
|
|
|
// Let clients know that this thread is exiting
|
|
comm->m_read_thread = LLDB_INVALID_HOST_THREAD;
|
|
comm->BroadcastEvent (eBroadcastBitReadThreadDidExit);
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
Communication::SetReadThreadBytesReceivedCallback
|
|
(
|
|
ReadThreadBytesReceived callback,
|
|
void *callback_baton
|
|
)
|
|
{
|
|
m_callback = callback;
|
|
m_callback_baton = callback_baton;
|
|
}
|
|
|
|
void
|
|
Communication::SetConnection (Connection *connection)
|
|
{
|
|
StopReadThread(NULL);
|
|
Disconnect (NULL);
|
|
m_connection_ap.reset(connection);
|
|
}
|