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