contrib/llvm/tools/lldb/source/Core/Communication.cpp

   1 //===-- Communication.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "lldb/lldb-private-log.h"
  15 #include "lldb/Core/Communication.h"
  16 #include "lldb/Core/Connection.h"
  17 #include "lldb/Core/Log.h"
  18 #include "lldb/Core/Timer.h"
  19 #include "lldb/Core/Event.h"
  20 #include "lldb/Host/Host.h"
  21 #include <string.h>
  22
  23 using namespace lldb;
  24 using namespace lldb_private;
  25
  26 ConstString &
  27 Communication::GetStaticBroadcasterClass ()
  28 {
  29     static ConstString class_name ("lldb.communication");
  30     return class_name;
  31 }
  32
  33 //----------------------------------------------------------------------
  34 // Constructor
  35 //----------------------------------------------------------------------
  36 Communication::Communication(const char *name) :
  37     Broadcaster (NULL, name),
  38     m_connection_sp (),
  39     m_read_thread (LLDB_INVALID_HOST_THREAD),
  40     m_read_thread_enabled (false),
  41     m_bytes(),
  42     m_bytes_mutex (Mutex::eMutexTypeRecursive),
  43     m_write_mutex (Mutex::eMutexTypeNormal),
  44     m_callback (NULL),
  45     m_callback_baton (NULL),
  46     m_close_on_eof (true)
  47
  48 {
  49     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
  50                                  "%p Communication::Communication (name = %s)",
  51                                  this, name);
  52
  53     SetEventName (eBroadcastBitDisconnected, "disconnected");
  54     SetEventName (eBroadcastBitReadThreadGotBytes, "got bytes");
  55     SetEventName (eBroadcastBitReadThreadDidExit, "read thread did exit");
  56     SetEventName (eBroadcastBitReadThreadShouldExit, "read thread should exit");
  57     SetEventName (eBroadcastBitPacketAvailable, "packet available");
  58
  59     CheckInWithManager();
  60 }
  61
  62 //----------------------------------------------------------------------
  63 // Destructor
  64 //----------------------------------------------------------------------
  65 Communication::~Communication()
  66 {
  67     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
  68                                  "%p Communication::~Communication (name = %s)",
  69                                  this, m_broadcaster_name.AsCString(""));
  70     Clear();
  71 }
  72
  73 void
  74 Communication::Clear()
  75 {
  76     SetReadThreadBytesReceivedCallback (NULL, NULL);
  77     Disconnect (NULL);
  78     StopReadThread (NULL);
  79 }
  80
  81 ConnectionStatus
  82 Communication::Connect (const char *url, Error *error_ptr)
  83 {
  84     Clear();
  85
  86     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Connect (url = %s)", this, url);
  87
  88     lldb::ConnectionSP connection_sp (m_connection_sp);
  89     if (connection_sp.get())
  90         return connection_sp->Connect (url, error_ptr);
  91     if (error_ptr)
  92         error_ptr->SetErrorString("Invalid connection.");
  93     return eConnectionStatusNoConnection;
  94 }
  95
  96 ConnectionStatus
  97 Communication::Disconnect (Error *error_ptr)
  98 {
  99     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION, "%p Communication::Disconnect ()", this);
 100
 101     lldb::ConnectionSP connection_sp (m_connection_sp);
 102     if (connection_sp.get())
 103     {
 104         ConnectionStatus status = connection_sp->Disconnect (error_ptr);
 105         // We currently don't protect connection_sp with any mutex for
 106         // multi-threaded environments. So lets not nuke our connection class
 107         // without putting some multi-threaded protections in. We also probably
 108         // don't want to pay for the overhead it might cause if every time we
 109         // access the connection we have to take a lock.
 110         //
 111         // This unique pointer will cleanup after itself when this object goes away,
 112         // so there is no need to currently have it destroy itself immediately
 113         // upon disconnnect.
 114         //connection_sp.reset();
 115         return status;
 116     }
 117     return eConnectionStatusNoConnection;
 118 }
 119
 120 bool
 121 Communication::IsConnected () const
 122 {
 123     lldb::ConnectionSP connection_sp (m_connection_sp);
 124     if (connection_sp.get())
 125         return connection_sp->IsConnected ();
 126     return false;
 127 }
 128
 129 bool
 130 Communication::HasConnection () const
 131 {
 132     return m_connection_sp.get() != NULL;
 133 }
 134
 135 size_t
 136 Communication::Read (void *dst, size_t dst_len, uint32_t timeout_usec, ConnectionStatus &status, Error *error_ptr)
 137 {
 138     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
 139                                          "%p Communication::Read (dst = %p, dst_len = %" PRIu64 ", timeout = %u usec) connection = %p",
 140                                          this,
 141                                          dst,
 142                                          (uint64_t)dst_len,
 143                                          timeout_usec,
 144                                          m_connection_sp.get());
 145
 146     if (m_read_thread_enabled)
 147     {
 148         // We have a dedicated read thread that is getting data for us
 149         size_t cached_bytes = GetCachedBytes (dst, dst_len);
 150         if (cached_bytes > 0 || timeout_usec == 0)
 151         {
 152             status = eConnectionStatusSuccess;
 153             return cached_bytes;
 154         }
 155
 156         if (m_connection_sp.get() == NULL)
 157         {
 158             if (error_ptr)
 159                 error_ptr->SetErrorString("Invalid connection.");
 160             status = eConnectionStatusNoConnection;
 161             return 0;
 162         }
 163         // Set the timeout appropriately
 164         TimeValue timeout_time;
 165         if (timeout_usec != UINT32_MAX)
 166         {
 167             timeout_time = TimeValue::Now();
 168             timeout_time.OffsetWithMicroSeconds (timeout_usec);
 169         }
 170
 171         Listener listener ("Communication::Read");
 172         listener.StartListeningForEvents (this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit);
 173         EventSP event_sp;
 174         while (listener.WaitForEvent (timeout_time.IsValid() ? &timeout_time : NULL, event_sp))
 175         {
 176             const uint32_t event_type = event_sp->GetType();
 177             if (event_type & eBroadcastBitReadThreadGotBytes)
 178             {
 179                 return GetCachedBytes (dst, dst_len);
 180             }
 181
 182             if (event_type & eBroadcastBitReadThreadDidExit)
 183             {
 184                 Disconnect (NULL);
 185                 break;
 186             }
 187         }
 188         return 0;
 189     }
 190
 191     // We aren't using a read thread, just read the data synchronously in this
 192     // thread.
 193     lldb::ConnectionSP connection_sp (m_connection_sp);
 194     if (connection_sp.get())
 195     {
 196         return connection_sp->Read (dst, dst_len, timeout_usec, status, error_ptr);
 197     }
 198
 199     if (error_ptr)
 200         error_ptr->SetErrorString("Invalid connection.");
 201     status = eConnectionStatusNoConnection;
 202     return 0;
 203 }
 204
 205
 206 size_t
 207 Communication::Write (const void *src, size_t src_len, ConnectionStatus &status, Error *error_ptr)
 208 {
 209     lldb::ConnectionSP connection_sp (m_connection_sp);
 210
 211     Mutex::Locker locker(m_write_mutex);
 212     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
 213                                          "%p Communication::Write (src = %p, src_len = %" PRIu64 ") connection = %p",
 214                                          this,
 215                                          src,
 216                                          (uint64_t)src_len,
 217                                          connection_sp.get());
 218
 219     if (connection_sp.get())
 220         return connection_sp->Write (src, src_len, status, error_ptr);
 221
 222     if (error_ptr)
 223         error_ptr->SetErrorString("Invalid connection.");
 224     status = eConnectionStatusNoConnection;
 225     return 0;
 226 }
 227
 228
 229 bool
 230 Communication::StartReadThread (Error *error_ptr)
 231 {
 232     if (error_ptr)
 233         error_ptr->Clear();
 234
 235     if (IS_VALID_LLDB_HOST_THREAD(m_read_thread))
 236         return true;
 237
 238     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
 239                                  "%p Communication::StartReadThread ()", this);
 240
 241
 242     char thread_name[1024];
 243     snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>", m_broadcaster_name.AsCString());
 244
 245     m_read_thread_enabled = true;
 246     m_read_thread = Host::ThreadCreate (thread_name, Communication::ReadThread, this, error_ptr);
 247     if (!IS_VALID_LLDB_HOST_THREAD(m_read_thread))
 248         m_read_thread_enabled = false;
 249     return m_read_thread_enabled;
 250 }
 251
 252 bool
 253 Communication::StopReadThread (Error *error_ptr)
 254 {
 255     if (!IS_VALID_LLDB_HOST_THREAD(m_read_thread))
 256         return true;
 257
 258     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
 259                                  "%p Communication::StopReadThread ()", this);
 260
 261     m_read_thread_enabled = false;
 262
 263     BroadcastEvent (eBroadcastBitReadThreadShouldExit, NULL);
 264
 265     //Host::ThreadCancel (m_read_thread, error_ptr);
 266
 267     bool status = Host::ThreadJoin (m_read_thread, NULL, error_ptr);
 268     m_read_thread = LLDB_INVALID_HOST_THREAD;
 269     return status;
 270 }
 271
 272
 273 size_t
 274 Communication::GetCachedBytes (void *dst, size_t dst_len)
 275 {
 276     Mutex::Locker locker(m_bytes_mutex);
 277     if (m_bytes.size() > 0)
 278     {
 279         // If DST is NULL and we have a thread, then return the number
 280         // of bytes that are available so the caller can call again
 281         if (dst == NULL)
 282             return m_bytes.size();
 283
 284         const size_t len = std::min<size_t>(dst_len, m_bytes.size());
 285
 286         ::memcpy (dst, m_bytes.c_str(), len);
 287         m_bytes.erase(m_bytes.begin(), m_bytes.begin() + len);
 288
 289         return len;
 290     }
 291     return 0;
 292 }
 293
 294 void
 295 Communication::AppendBytesToCache (const uint8_t * bytes, size_t len, bool broadcast, ConnectionStatus status)
 296 {
 297     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
 298                                  "%p Communication::AppendBytesToCache (src = %p, src_len = %" PRIu64 ", broadcast = %i)",
 299                                  this, bytes, (uint64_t)len, broadcast);
 300     if ((bytes == NULL || len == 0)
 301         && (status != lldb::eConnectionStatusEndOfFile))
 302         return;
 303     if (m_callback)
 304     {
 305         // If the user registered a callback, then call it and do not broadcast
 306         m_callback (m_callback_baton, bytes, len);
 307     }
 308     else if (bytes != NULL && len > 0)
 309     {
 310         Mutex::Locker locker(m_bytes_mutex);
 311         m_bytes.append ((const char *)bytes, len);
 312         if (broadcast)
 313             BroadcastEventIfUnique (eBroadcastBitReadThreadGotBytes);
 314     }
 315 }
 316
 317 size_t
 318 Communication::ReadFromConnection (void *dst,
 319                                    size_t dst_len,
 320                                    uint32_t timeout_usec,
 321                                    ConnectionStatus &status,
 322                                    Error *error_ptr)
 323 {
 324     lldb::ConnectionSP connection_sp (m_connection_sp);
 325     if (connection_sp.get())
 326         return connection_sp->Read (dst, dst_len, timeout_usec, status, error_ptr);
 327     return 0;
 328 }
 329
 330 bool
 331 Communication::ReadThreadIsRunning ()
 332 {
 333     return m_read_thread_enabled;
 334 }
 335
 336 void *
 337 Communication::ReadThread (void *p)
 338 {
 339     Communication *comm = (Communication *)p;
 340
 341     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMUNICATION));
 342
 343     if (log)
 344         log->Printf ("%p Communication::ReadThread () thread starting...", p);
 345
 346     uint8_t buf[1024];
 347
 348     Error error;
 349     ConnectionStatus status = eConnectionStatusSuccess;
 350     bool done = false;
 351     while (!done && comm->m_read_thread_enabled)
 352     {
 353         size_t bytes_read = comm->ReadFromConnection (buf, sizeof(buf), 5 * TimeValue::MicroSecPerSec, status, &error);
 354         if (bytes_read > 0)
 355             comm->AppendBytesToCache (buf, bytes_read, true, status);
 356         else if ((bytes_read == 0)
 357                 && status == eConnectionStatusEndOfFile)
 358         {
 359             if (comm->GetCloseOnEOF ())
 360                 comm->Disconnect ();
 361             comm->AppendBytesToCache (buf, bytes_read, true, status);
 362         }
 363
 364         switch (status)
 365         {
 366         case eConnectionStatusSuccess:
 367             break;
 368
 369         case eConnectionStatusEndOfFile:
 370             if (comm->GetCloseOnEOF())
 371                  done = true;
 372              break;
 373         case eConnectionStatusNoConnection:     // No connection
 374         case eConnectionStatusLostConnection:   // Lost connection while connected to a valid connection
 375             done = true;
 376             // Fall through...
 377         case eConnectionStatusError:            // Check GetError() for details
 378         case eConnectionStatusTimedOut:         // Request timed out
 379             if (log)
 380                 error.LogIfError (log,
 381                                   "%p Communication::ReadFromConnection () => status = %s",
 382                                   p,
 383                                   Communication::ConnectionStatusAsCString (status));
 384             break;
 385         }
 386     }
 387     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMUNICATION);
 388     if (log)
 389         log->Printf ("%p Communication::ReadThread () thread exiting...", p);
 390
 391     // Let clients know that this thread is exiting
 392     comm->BroadcastEvent (eBroadcastBitReadThreadDidExit);
 393     return NULL;
 394 }
 395
 396 void
 397 Communication::SetReadThreadBytesReceivedCallback
 398 (
 399     ReadThreadBytesReceived callback,
 400     void *callback_baton
 401 )
 402 {
 403     m_callback = callback;
 404     m_callback_baton = callback_baton;
 405 }
 406
 407 void
 408 Communication::SetConnection (Connection *connection)
 409 {
 410     Disconnect (NULL);
 411     StopReadThread(NULL);
 412     m_connection_sp.reset(connection);
 413 }
 414
 415 const char *
 416 Communication::ConnectionStatusAsCString (lldb::ConnectionStatus status)
 417 {
 418     switch (status)
 419     {
 420     case eConnectionStatusSuccess:        return "success";
 421     case eConnectionStatusError:          return "error";
 422     case eConnectionStatusTimedOut:       return "timed out";
 423     case eConnectionStatusNoConnection:   return "no connection";
 424     case eConnectionStatusLostConnection: return "lost connection";
 425     case eConnectionStatusEndOfFile:      return "end of file";
 426     }
 427
 428     static char unknown_state_string[64];
 429     snprintf(unknown_state_string, sizeof (unknown_state_string), "ConnectionStatus = %i", status);
 430     return unknown_state_string;
 431 }