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 &
GetStaticBroadcasterClass()27 Communication::GetStaticBroadcasterClass ()
28 {
29     static ConstString class_name ("lldb.communication");
30     return class_name;
31 }
32 
33 //----------------------------------------------------------------------
34 // Constructor
35 //----------------------------------------------------------------------
Communication(const char * name)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 //----------------------------------------------------------------------
~Communication()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
Clear()74 Communication::Clear()
75 {
76     SetReadThreadBytesReceivedCallback (NULL, NULL);
77     Disconnect (NULL);
78     StopReadThread (NULL);
79 }
80 
81 ConnectionStatus
Connect(const char * url,Error * error_ptr)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
Disconnect(Error * error_ptr)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
IsConnected() const121 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
HasConnection() const130 Communication::HasConnection () const
131 {
132     return m_connection_sp.get() != NULL;
133 }
134 
135 size_t
Read(void * dst,size_t dst_len,uint32_t timeout_usec,ConnectionStatus & status,Error * error_ptr)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
Write(const void * src,size_t src_len,ConnectionStatus & status,Error * error_ptr)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
StartReadThread(Error * error_ptr)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
StopReadThread(Error * error_ptr)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
GetCachedBytes(void * dst,size_t dst_len)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
AppendBytesToCache(const uint8_t * bytes,size_t len,bool broadcast,ConnectionStatus status)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
ReadFromConnection(void * dst,size_t dst_len,uint32_t timeout_usec,ConnectionStatus & status,Error * error_ptr)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
ReadThreadIsRunning()331 Communication::ReadThreadIsRunning ()
332 {
333     return m_read_thread_enabled;
334 }
335 
336 void *
ReadThread(void * p)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
SetReadThreadBytesReceivedCallback(ReadThreadBytesReceived callback,void * callback_baton)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
SetConnection(Connection * connection)408 Communication::SetConnection (Connection *connection)
409 {
410     Disconnect (NULL);
411     StopReadThread(NULL);
412     m_connection_sp.reset(connection);
413 }
414 
415 const char *
ConnectionStatusAsCString(lldb::ConnectionStatus status)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 }
432