1 //===-- Listener.cpp --------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Utility/Listener.h"
12 #include "lldb/Utility/Broadcaster.h"
13 #include "lldb/Utility/ConstString.h"
14 #include "lldb/Utility/Event.h"
15 #include "lldb/Utility/Log.h"
16 #include "lldb/Utility/Logging.h"
18 #include "llvm/ADT/Optional.h"
25 using namespace lldb_private;
28 class BroadcasterManagerWPMatcher {
30 BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
31 : m_manager_sp(manager_sp) {}
32 bool operator()(const BroadcasterManagerWP input_wp) const {
33 BroadcasterManagerSP input_sp = input_wp.lock();
34 return (input_sp && input_sp == m_manager_sp);
37 BroadcasterManagerSP m_manager_sp;
39 } // anonymous namespace
41 Listener::Listener(const char *name)
42 : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
44 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
46 log->Printf("%p Listener::Listener('%s')", static_cast<void *>(this),
50 Listener::~Listener() {
51 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
56 log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
57 __FUNCTION__, m_name.c_str());
60 void Listener::Clear() {
61 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
62 std::lock_guard<std::recursive_mutex> broadcasters_guard(
63 m_broadcasters_mutex);
64 broadcaster_collection::iterator pos, end = m_broadcasters.end();
65 for (pos = m_broadcasters.begin(); pos != end; ++pos) {
66 Broadcaster::BroadcasterImplSP broadcaster_sp(pos->first.lock());
68 broadcaster_sp->RemoveListener(this, pos->second.event_mask);
70 m_broadcasters.clear();
72 std::lock_guard<std::mutex> events_guard(m_events_mutex);
74 size_t num_managers = m_broadcaster_managers.size();
76 for (size_t i = 0; i < num_managers; i++) {
77 BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock());
79 manager_sp->RemoveListener(this);
83 log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
84 __FUNCTION__, m_name.c_str());
87 uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
88 uint32_t event_mask) {
91 // Tell the broadcaster to add this object as a listener
93 std::lock_guard<std::recursive_mutex> broadcasters_guard(
94 m_broadcasters_mutex);
95 Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
96 m_broadcasters.insert(
97 std::make_pair(impl_wp, BroadcasterInfo(event_mask)));
100 uint32_t acquired_mask =
101 broadcaster->AddListener(this->shared_from_this(), event_mask);
103 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
105 log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
106 "mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
107 static_cast<void *>(this), static_cast<void *>(broadcaster),
108 event_mask, acquired_mask, m_name.c_str());
110 return acquired_mask;
115 uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
117 HandleBroadcastCallback callback,
118 void *callback_user_data) {
120 // Scope for "locker"
121 // Tell the broadcaster to add this object as a listener
123 std::lock_guard<std::recursive_mutex> broadcasters_guard(
124 m_broadcasters_mutex);
125 Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
126 m_broadcasters.insert(std::make_pair(
127 impl_wp, BroadcasterInfo(event_mask, callback, callback_user_data)));
130 uint32_t acquired_mask =
131 broadcaster->AddListener(this->shared_from_this(), event_mask);
133 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
134 if (log != nullptr) {
135 void **pointer = reinterpret_cast<void **>(&callback);
136 log->Printf("%p Listener::StartListeningForEvents (broadcaster = %p, "
137 "mask = 0x%8.8x, callback = %p, user_data = %p) "
138 "acquired_mask = 0x%8.8x for %s",
139 static_cast<void *>(this), static_cast<void *>(broadcaster),
140 event_mask, *pointer, static_cast<void *>(callback_user_data),
141 acquired_mask, m_name.c_str());
144 return acquired_mask;
149 bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
150 uint32_t event_mask) {
152 // Scope for "locker"
154 std::lock_guard<std::recursive_mutex> broadcasters_guard(
155 m_broadcasters_mutex);
156 m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
158 // Remove the broadcaster from our set of broadcasters
159 return broadcaster->RemoveListener(this->shared_from_this(), event_mask);
165 // Called when a Broadcaster is in its destructor. We need to remove all
166 // knowledge of this broadcaster and any events that it may have queued up
167 void Listener::BroadcasterWillDestruct(Broadcaster *broadcaster) {
168 // Scope for "broadcasters_locker"
170 std::lock_guard<std::recursive_mutex> broadcasters_guard(
171 m_broadcasters_mutex);
172 m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
175 // Scope for "event_locker"
177 std::lock_guard<std::mutex> events_guard(m_events_mutex);
178 // Remove all events for this broadcaster object.
179 event_collection::iterator pos = m_events.begin();
180 while (pos != m_events.end()) {
181 if ((*pos)->GetBroadcaster() == broadcaster)
182 pos = m_events.erase(pos);
189 void Listener::BroadcasterManagerWillDestruct(BroadcasterManagerSP manager_sp) {
190 // Just need to remove this broadcast manager from the list of managers:
191 broadcaster_manager_collection::iterator iter,
192 end_iter = m_broadcaster_managers.end();
193 BroadcasterManagerWP manager_wp;
195 BroadcasterManagerWPMatcher matcher(manager_sp);
196 iter = std::find_if<broadcaster_manager_collection::iterator,
197 BroadcasterManagerWPMatcher>(
198 m_broadcaster_managers.begin(), end_iter, matcher);
199 if (iter != end_iter)
200 m_broadcaster_managers.erase(iter);
203 void Listener::AddEvent(EventSP &event_sp) {
204 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
206 log->Printf("%p Listener('%s')::AddEvent (event_sp = {%p})",
207 static_cast<void *>(this), m_name.c_str(),
208 static_cast<void *>(event_sp.get()));
210 std::lock_guard<std::mutex> guard(m_events_mutex);
211 m_events.push_back(event_sp);
212 m_events_condition.notify_all();
215 class EventBroadcasterMatches {
217 EventBroadcasterMatches(Broadcaster *broadcaster)
218 : m_broadcaster(broadcaster) {}
220 bool operator()(const EventSP &event_sp) const {
221 return event_sp->BroadcasterIs(m_broadcaster);
225 Broadcaster *m_broadcaster;
230 EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
231 uint32_t num_broadcaster_names, uint32_t event_type_mask)
232 : m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
233 m_num_broadcaster_names(num_broadcaster_names),
234 m_event_type_mask(event_type_mask) {}
236 bool operator()(const EventSP &event_sp) const {
237 if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
240 if (m_broadcaster_names) {
241 bool found_source = false;
242 const ConstString &event_broadcaster_name =
243 event_sp->GetBroadcaster()->GetBroadcasterName();
244 for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
245 if (m_broadcaster_names[i] == event_broadcaster_name) {
254 return m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType();
258 Broadcaster *m_broadcaster;
259 const ConstString *m_broadcaster_names;
260 const uint32_t m_num_broadcaster_names;
261 const uint32_t m_event_type_mask;
264 bool Listener::FindNextEventInternal(
265 std::unique_lock<std::mutex> &lock,
266 Broadcaster *broadcaster, // nullptr for any broadcaster
267 const ConstString *broadcaster_names, // nullptr for any event
268 uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
270 // NOTE: callers of this function must lock m_events_mutex using a
272 // and pass the locker as the first argument. m_events_mutex is no longer
274 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
276 if (m_events.empty())
279 Listener::event_collection::iterator pos = m_events.end();
281 if (broadcaster == nullptr && broadcaster_names == nullptr &&
282 event_type_mask == 0) {
283 pos = m_events.begin();
285 pos = std::find_if(m_events.begin(), m_events.end(),
286 EventMatcher(broadcaster, broadcaster_names,
287 num_broadcaster_names, event_type_mask));
290 if (pos != m_events.end()) {
294 log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
295 "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
296 "remove=%i) event %p",
297 static_cast<void *>(this), GetName(),
298 static_cast<void *>(broadcaster),
299 static_cast<const void *>(broadcaster_names),
300 num_broadcaster_names, event_type_mask, remove,
301 static_cast<void *>(event_sp.get()));
305 // Unlock the event queue here. We've removed this event and are about
306 // to return it so it should be okay to get the next event off the queue
307 // here - and it might be useful to do that in the "DoOnRemoval".
309 event_sp->DoOnRemoval();
318 Event *Listener::PeekAtNextEvent() {
319 std::unique_lock<std::mutex> guard(m_events_mutex);
321 if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
322 return event_sp.get();
326 Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
327 std::unique_lock<std::mutex> guard(m_events_mutex);
329 if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
330 return event_sp.get();
335 Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
336 uint32_t event_type_mask) {
337 std::unique_lock<std::mutex> guard(m_events_mutex);
339 if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
341 return event_sp.get();
345 bool Listener::GetEventInternal(
346 const Timeout<std::micro> &timeout,
347 Broadcaster *broadcaster, // nullptr for any broadcaster
348 const ConstString *broadcaster_names, // nullptr for any event
349 uint32_t num_broadcaster_names, uint32_t event_type_mask,
351 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
352 LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
354 std::unique_lock<std::mutex> lock(m_events_mutex);
357 if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
358 num_broadcaster_names, event_type_mask, event_sp,
362 std::cv_status result = std::cv_status::no_timeout;
364 m_events_condition.wait(lock);
366 result = m_events_condition.wait_for(lock, *timeout);
368 if (result == std::cv_status::timeout) {
369 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
371 log->Printf("%p Listener::GetEventInternal() timed out for %s",
372 static_cast<void *>(this), m_name.c_str());
374 } else if (result != std::cv_status::no_timeout) {
375 log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
377 log->Printf("%p Listener::GetEventInternal() unknown error for %s",
378 static_cast<void *>(this), m_name.c_str());
387 bool Listener::GetEventForBroadcasterWithType(
388 Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
389 const Timeout<std::micro> &timeout) {
390 return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
394 bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
396 const Timeout<std::micro> &timeout) {
397 return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
400 bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
401 return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
404 size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
405 size_t num_handled = 0;
406 std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
407 Broadcaster *broadcaster = event_sp->GetBroadcaster();
410 broadcaster_collection::iterator pos;
411 broadcaster_collection::iterator end = m_broadcasters.end();
412 Broadcaster::BroadcasterImplSP broadcaster_impl_sp(
413 broadcaster->GetBroadcasterImpl());
414 for (pos = m_broadcasters.find(broadcaster_impl_sp);
415 pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
416 BroadcasterInfo info = pos->second;
417 if (event_sp->GetType() & info.event_mask) {
418 if (info.callback != nullptr) {
419 info.callback(event_sp, info.callback_user_data);
428 Listener::StartListeningForEventSpec(BroadcasterManagerSP manager_sp,
429 const BroadcastEventSpec &event_spec) {
433 // The BroadcasterManager mutex must be locked before m_broadcasters_mutex to
434 // avoid violating the lock hierarchy (manager before broadcasters).
435 std::lock_guard<std::recursive_mutex> manager_guard(
436 manager_sp->m_manager_mutex);
437 std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
439 uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
440 this->shared_from_this(), event_spec);
442 broadcaster_manager_collection::iterator iter,
443 end_iter = m_broadcaster_managers.end();
444 BroadcasterManagerWP manager_wp(manager_sp);
445 BroadcasterManagerWPMatcher matcher(manager_sp);
446 iter = std::find_if<broadcaster_manager_collection::iterator,
447 BroadcasterManagerWPMatcher>(
448 m_broadcaster_managers.begin(), end_iter, matcher);
449 if (iter == end_iter)
450 m_broadcaster_managers.push_back(manager_wp);
453 return bits_acquired;
456 bool Listener::StopListeningForEventSpec(BroadcasterManagerSP manager_sp,
457 const BroadcastEventSpec &event_spec) {
461 std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
462 return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
466 ListenerSP Listener::MakeListener(const char *name) {
467 return ListenerSP(new Listener(name));