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