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