1 //===-- Broadcaster.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 #include "lldb/Utility/Broadcaster.h"
11 
12 #include "lldb/Utility/Event.h"
13 #include "lldb/Utility/Listener.h"
14 #include "lldb/Utility/Log.h"
15 #include "lldb/Utility/Logging.h"
16 #include "lldb/Utility/Stream.h"
17 #include "lldb/Utility/StreamString.h"
18 
19 #include <algorithm>
20 #include <memory>
21 #include <type_traits>
22 
23 #include <assert.h>
24 #include <stddef.h>
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 
29 Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name)
30     : m_broadcaster_sp(std::make_shared<BroadcasterImpl>(*this)),
31       m_manager_sp(manager_sp), m_broadcaster_name(name) {
32   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
33   if (log)
34     log->Printf("%p Broadcaster::Broadcaster(\"%s\")",
35                 static_cast<void *>(this), GetBroadcasterName().AsCString());
36 }
37 
38 Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster)
39     : m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(),
40       m_hijacking_listeners(), m_hijacking_masks() {}
41 
42 Broadcaster::~Broadcaster() {
43   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
44   if (log)
45     log->Printf("%p Broadcaster::~Broadcaster(\"%s\")",
46                 static_cast<void *>(this), m_broadcaster_name.AsCString());
47 
48   Clear();
49 }
50 
51 void Broadcaster::CheckInWithManager() {
52   if (m_manager_sp) {
53     m_manager_sp->SignUpListenersForBroadcaster(*this);
54   }
55 }
56 
57 llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4>
58 Broadcaster::BroadcasterImpl::GetListeners() {
59   llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
60   listeners.reserve(m_listeners.size());
61 
62   for (auto it = m_listeners.begin(); it != m_listeners.end();) {
63     lldb::ListenerSP curr_listener_sp(it->first.lock());
64     if (curr_listener_sp && it->second) {
65       listeners.emplace_back(std::move(curr_listener_sp), it->second);
66       ++it;
67     } else
68       it = m_listeners.erase(it);
69   }
70 
71   return listeners;
72 }
73 
74 void Broadcaster::BroadcasterImpl::Clear() {
75   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
76 
77   // Make sure the listener forgets about this broadcaster. We do this in the
78   // broadcaster in case the broadcaster object initiates the removal.
79   for (auto &pair : GetListeners())
80     pair.first->BroadcasterWillDestruct(&m_broadcaster);
81 
82   m_listeners.clear();
83 }
84 
85 Broadcaster *Broadcaster::BroadcasterImpl::GetBroadcaster() {
86   return &m_broadcaster;
87 }
88 
89 bool Broadcaster::BroadcasterImpl::GetEventNames(
90     Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const {
91   uint32_t num_names_added = 0;
92   if (event_mask && !m_event_names.empty()) {
93     event_names_map::const_iterator end = m_event_names.end();
94     for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
95          bit <<= 1, mask >>= 1) {
96       if (mask & 1) {
97         event_names_map::const_iterator pos = m_event_names.find(bit);
98         if (pos != end) {
99           if (num_names_added > 0)
100             s.PutCString(", ");
101 
102           if (prefix_with_broadcaster_name) {
103             s.PutCString(GetBroadcasterName());
104             s.PutChar('.');
105           }
106           s.PutCString(pos->second);
107           ++num_names_added;
108         }
109       }
110     }
111   }
112   return num_names_added > 0;
113 }
114 
115 void Broadcaster::AddInitialEventsToListener(
116     const lldb::ListenerSP &listener_sp, uint32_t requested_events) {}
117 
118 uint32_t
119 Broadcaster::BroadcasterImpl::AddListener(const lldb::ListenerSP &listener_sp,
120                                           uint32_t event_mask) {
121   if (!listener_sp)
122     return 0;
123 
124   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
125 
126   // See if we already have this listener, and if so, update its mask
127 
128   bool handled = false;
129 
130   for (auto &pair : GetListeners()) {
131     if (pair.first == listener_sp) {
132       handled = true;
133       pair.second |= event_mask;
134       m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
135       break;
136     }
137   }
138 
139   if (!handled) {
140     // Grant a new listener the available event bits
141     m_listeners.push_back(
142         std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
143 
144     // Individual broadcasters decide whether they have outstanding data when a
145     // listener attaches, and insert it into the listener with this method.
146     m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
147   }
148 
149   // Return the event bits that were granted to the listener
150   return event_mask;
151 }
152 
153 bool Broadcaster::BroadcasterImpl::EventTypeHasListeners(uint32_t event_type) {
154   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
155 
156   if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
157     return true;
158 
159   for (auto &pair : GetListeners()) {
160     if (pair.second & event_type)
161       return true;
162   }
163   return false;
164 }
165 
166 bool Broadcaster::BroadcasterImpl::RemoveListener(
167     lldb_private::Listener *listener, uint32_t event_mask) {
168   if (!listener)
169     return false;
170 
171   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
172   for (auto &pair : GetListeners()) {
173     if (pair.first.get() == listener) {
174       pair.second &= ~event_mask;
175       return true;
176     }
177   }
178   return false;
179 }
180 
181 bool Broadcaster::BroadcasterImpl::RemoveListener(
182     const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
183   return RemoveListener(listener_sp.get(), event_mask);
184 }
185 
186 void Broadcaster::BroadcasterImpl::BroadcastEvent(EventSP &event_sp) {
187   return PrivateBroadcastEvent(event_sp, false);
188 }
189 
190 void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(EventSP &event_sp) {
191   return PrivateBroadcastEvent(event_sp, true);
192 }
193 
194 void Broadcaster::BroadcasterImpl::PrivateBroadcastEvent(EventSP &event_sp,
195                                                          bool unique) {
196   // Can't add a nullptr event...
197   if (!event_sp)
198     return;
199 
200   // Update the broadcaster on this event
201   event_sp->SetBroadcaster(&m_broadcaster);
202 
203   const uint32_t event_type = event_sp->GetType();
204 
205   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
206 
207   ListenerSP hijacking_listener_sp;
208 
209   if (!m_hijacking_listeners.empty()) {
210     assert(!m_hijacking_masks.empty());
211     hijacking_listener_sp = m_hijacking_listeners.back();
212     if ((event_type & m_hijacking_masks.back()) == 0)
213       hijacking_listener_sp.reset();
214   }
215 
216   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
217   if (log) {
218     StreamString event_description;
219     event_sp->Dump(&event_description);
220     log->Printf("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, "
221                 "unique =%i) hijack = %p",
222                 static_cast<void *>(this), GetBroadcasterName(),
223                 event_description.GetData(), unique,
224                 static_cast<void *>(hijacking_listener_sp.get()));
225   }
226 
227   if (hijacking_listener_sp) {
228     if (unique &&
229         hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
230             &m_broadcaster, event_type))
231       return;
232     hijacking_listener_sp->AddEvent(event_sp);
233   } else {
234     for (auto &pair : GetListeners()) {
235       if (!(pair.second & event_type))
236         continue;
237       if (unique &&
238           pair.first->PeekAtNextEventForBroadcasterWithType(&m_broadcaster,
239                                                             event_type))
240         continue;
241 
242       pair.first->AddEvent(event_sp);
243     }
244   }
245 }
246 
247 void Broadcaster::BroadcasterImpl::BroadcastEvent(uint32_t event_type,
248                                                   EventData *event_data) {
249   auto event_sp = std::make_shared<Event>(event_type, event_data);
250   PrivateBroadcastEvent(event_sp, false);
251 }
252 
253 void Broadcaster::BroadcasterImpl::BroadcastEvent(
254     uint32_t event_type, const lldb::EventDataSP &event_data_sp) {
255   auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
256   PrivateBroadcastEvent(event_sp, false);
257 }
258 
259 void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(
260     uint32_t event_type, EventData *event_data) {
261   auto event_sp = std::make_shared<Event>(event_type, event_data);
262   PrivateBroadcastEvent(event_sp, true);
263 }
264 
265 bool Broadcaster::BroadcasterImpl::HijackBroadcaster(
266     const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
267   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
268 
269   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
270   if (log)
271     log->Printf(
272         "%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
273         static_cast<void *>(this), GetBroadcasterName(),
274         listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
275   m_hijacking_listeners.push_back(listener_sp);
276   m_hijacking_masks.push_back(event_mask);
277   return true;
278 }
279 
280 bool Broadcaster::BroadcasterImpl::IsHijackedForEvent(uint32_t event_mask) {
281   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
282 
283   if (!m_hijacking_listeners.empty())
284     return (event_mask & m_hijacking_masks.back()) != 0;
285   return false;
286 }
287 
288 const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
289   if (m_hijacking_listeners.size()) {
290     return m_hijacking_listeners.back()->GetName();
291   } else {
292     return nullptr;
293   }
294 }
295 
296 void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
297   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
298 
299   if (!m_hijacking_listeners.empty()) {
300     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EVENTS));
301     if (log) {
302       ListenerSP listener_sp = m_hijacking_listeners.back();
303       log->Printf("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop "
304                   "listener(\"%s\")=%p)",
305                   static_cast<void *>(this), GetBroadcasterName(),
306                   listener_sp->m_name.c_str(),
307                   static_cast<void *>(listener_sp.get()));
308     }
309     m_hijacking_listeners.pop_back();
310   }
311   if (!m_hijacking_masks.empty())
312     m_hijacking_masks.pop_back();
313 }
314 
315 ConstString &Broadcaster::GetBroadcasterClass() const {
316   static ConstString class_name("lldb.anonymous");
317   return class_name;
318 }
319 
320 BroadcastEventSpec::BroadcastEventSpec(const BroadcastEventSpec &rhs) = default;
321 
322 bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
323   if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
324     return GetEventBits() < rhs.GetEventBits();
325   } else {
326     return GetBroadcasterClass() < rhs.GetBroadcasterClass();
327   }
328 }
329 
330 BroadcastEventSpec &BroadcastEventSpec::
331 operator=(const BroadcastEventSpec &rhs) = default;
332 
333 BroadcasterManager::BroadcasterManager() : m_manager_mutex() {}
334 
335 lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() {
336   return lldb::BroadcasterManagerSP(new BroadcasterManager());
337 }
338 
339 uint32_t BroadcasterManager::RegisterListenerForEvents(
340     const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
341   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
342 
343   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
344   uint32_t available_bits = event_spec.GetEventBits();
345 
346   while (iter != end_iter &&
347          (iter = find_if(iter, end_iter,
348                          BroadcasterClassMatches(
349                              event_spec.GetBroadcasterClass()))) != end_iter) {
350     available_bits &= ~((*iter).first.GetEventBits());
351     iter++;
352   }
353 
354   if (available_bits != 0) {
355     m_event_map.insert(event_listener_key(
356         BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
357         listener_sp));
358     m_listeners.insert(listener_sp);
359   }
360 
361   return available_bits;
362 }
363 
364 bool BroadcasterManager::UnregisterListenerForEvents(
365     const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec) {
366   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
367   bool removed_some = false;
368 
369   if (m_listeners.erase(listener_sp) == 0)
370     return false;
371 
372   ListenerMatchesAndSharedBits predicate(event_spec, listener_sp);
373   std::vector<BroadcastEventSpec> to_be_readded;
374   uint32_t event_bits_to_remove = event_spec.GetEventBits();
375 
376   // Go through the map and delete the exact matches, and build a list of
377   // matches that weren't exact to re-add:
378   while (true) {
379     collection::iterator iter, end_iter = m_event_map.end();
380     iter = find_if(m_event_map.begin(), end_iter, predicate);
381     if (iter == end_iter) {
382       break;
383     } else {
384       uint32_t iter_event_bits = (*iter).first.GetEventBits();
385       removed_some = true;
386 
387       if (event_bits_to_remove != iter_event_bits) {
388         uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
389         to_be_readded.push_back(BroadcastEventSpec(
390             event_spec.GetBroadcasterClass(), new_event_bits));
391       }
392       m_event_map.erase(iter);
393     }
394   }
395 
396   // Okay now add back the bits that weren't completely removed:
397   for (size_t i = 0; i < to_be_readded.size(); i++) {
398     m_event_map.insert(event_listener_key(to_be_readded[i], listener_sp));
399   }
400 
401   return removed_some;
402 }
403 
404 ListenerSP BroadcasterManager::GetListenerForEventSpec(
405     BroadcastEventSpec event_spec) const {
406   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
407 
408   collection::const_iterator iter, end_iter = m_event_map.end();
409   iter = find_if(m_event_map.begin(), end_iter,
410                  BroadcastEventSpecMatches(event_spec));
411   if (iter != end_iter)
412     return (*iter).second;
413   else
414     return nullptr;
415 }
416 
417 void BroadcasterManager::RemoveListener(Listener *listener) {
418   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
419   ListenerMatchesPointer predicate(listener);
420   listener_collection::iterator iter = m_listeners.begin(),
421                                 end_iter = m_listeners.end();
422 
423   std::find_if(iter, end_iter, predicate);
424   if (iter != end_iter)
425     m_listeners.erase(iter);
426 
427   while (true) {
428     collection::iterator iter, end_iter = m_event_map.end();
429     iter = find_if(m_event_map.begin(), end_iter, predicate);
430     if (iter == end_iter)
431       break;
432     else
433       m_event_map.erase(iter);
434   }
435 }
436 
437 void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
438   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
439   ListenerMatches predicate(listener_sp);
440 
441   if (m_listeners.erase(listener_sp) == 0)
442     return;
443 
444   while (true) {
445     collection::iterator iter, end_iter = m_event_map.end();
446     iter = find_if(m_event_map.begin(), end_iter, predicate);
447     if (iter == end_iter)
448       break;
449     else
450       m_event_map.erase(iter);
451   }
452 }
453 
454 void BroadcasterManager::SignUpListenersForBroadcaster(
455     Broadcaster &broadcaster) {
456   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
457 
458   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
459 
460   while (iter != end_iter &&
461          (iter = find_if(iter, end_iter,
462                          BroadcasterClassMatches(
463                              broadcaster.GetBroadcasterClass()))) != end_iter) {
464     (*iter).second->StartListeningForEvents(&broadcaster,
465                                             (*iter).first.GetEventBits());
466     iter++;
467   }
468 }
469 
470 void BroadcasterManager::Clear() {
471   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
472   listener_collection::iterator end_iter = m_listeners.end();
473 
474   for (listener_collection::iterator iter = m_listeners.begin();
475        iter != end_iter; iter++)
476     (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
477   m_listeners.clear();
478   m_event_map.clear();
479 }
480