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