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