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 log->Printf("%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 BroadcastEventSpec &BroadcastEventSpec:: 321 operator=(const BroadcastEventSpec &rhs) = default; 322 323 BroadcasterManager::BroadcasterManager() : m_manager_mutex() {} 324 325 lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() { 326 return lldb::BroadcasterManagerSP(new BroadcasterManager()); 327 } 328 329 uint32_t BroadcasterManager::RegisterListenerForEvents( 330 const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) { 331 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 332 333 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end(); 334 uint32_t available_bits = event_spec.GetEventBits(); 335 336 while (iter != end_iter && 337 (iter = find_if(iter, end_iter, 338 BroadcasterClassMatches( 339 event_spec.GetBroadcasterClass()))) != end_iter) { 340 available_bits &= ~((*iter).first.GetEventBits()); 341 iter++; 342 } 343 344 if (available_bits != 0) { 345 m_event_map.insert(event_listener_key( 346 BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits), 347 listener_sp)); 348 m_listeners.insert(listener_sp); 349 } 350 351 return available_bits; 352 } 353 354 bool BroadcasterManager::UnregisterListenerForEvents( 355 const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) { 356 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 357 bool removed_some = false; 358 359 if (m_listeners.erase(listener_sp) == 0) 360 return false; 361 362 ListenerMatchesAndSharedBits predicate(event_spec, listener_sp); 363 std::vector<BroadcastEventSpec> to_be_readded; 364 uint32_t event_bits_to_remove = event_spec.GetEventBits(); 365 366 // Go through the map and delete the exact matches, and build a list of 367 // matches that weren't exact to re-add: 368 while (true) { 369 collection::iterator iter, end_iter = m_event_map.end(); 370 iter = find_if(m_event_map.begin(), end_iter, predicate); 371 if (iter == end_iter) { 372 break; 373 } 374 uint32_t iter_event_bits = (*iter).first.GetEventBits(); 375 removed_some = true; 376 377 if (event_bits_to_remove != iter_event_bits) { 378 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove; 379 to_be_readded.push_back( 380 BroadcastEventSpec(event_spec.GetBroadcasterClass(), new_event_bits)); 381 } 382 m_event_map.erase(iter); 383 } 384 385 // Okay now add back the bits that weren't completely removed: 386 for (size_t i = 0; i < to_be_readded.size(); i++) { 387 m_event_map.insert(event_listener_key(to_be_readded[i], listener_sp)); 388 } 389 390 return removed_some; 391 } 392 393 ListenerSP BroadcasterManager::GetListenerForEventSpec( 394 const BroadcastEventSpec &event_spec) const { 395 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 396 397 collection::const_iterator iter, end_iter = m_event_map.end(); 398 iter = find_if(m_event_map.begin(), end_iter, 399 BroadcastEventSpecMatches(event_spec)); 400 if (iter != end_iter) 401 return (*iter).second; 402 403 return nullptr; 404 } 405 406 void BroadcasterManager::RemoveListener(Listener *listener) { 407 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 408 ListenerMatchesPointer predicate(listener); 409 listener_collection::iterator iter = m_listeners.begin(), 410 end_iter = m_listeners.end(); 411 412 std::find_if(iter, end_iter, predicate); 413 if (iter != end_iter) 414 m_listeners.erase(iter); 415 416 while (true) { 417 collection::iterator iter, end_iter = m_event_map.end(); 418 iter = find_if(m_event_map.begin(), end_iter, predicate); 419 if (iter == end_iter) 420 break; 421 422 m_event_map.erase(iter); 423 } 424 } 425 426 void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) { 427 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 428 ListenerMatches predicate(listener_sp); 429 430 if (m_listeners.erase(listener_sp) == 0) 431 return; 432 433 while (true) { 434 collection::iterator iter, end_iter = m_event_map.end(); 435 iter = find_if(m_event_map.begin(), end_iter, predicate); 436 if (iter == end_iter) 437 break; 438 439 m_event_map.erase(iter); 440 } 441 } 442 443 void BroadcasterManager::SignUpListenersForBroadcaster( 444 Broadcaster &broadcaster) { 445 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 446 447 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end(); 448 449 while (iter != end_iter && 450 (iter = find_if(iter, end_iter, 451 BroadcasterClassMatches( 452 broadcaster.GetBroadcasterClass()))) != end_iter) { 453 (*iter).second->StartListeningForEvents(&broadcaster, 454 (*iter).first.GetEventBits()); 455 iter++; 456 } 457 } 458 459 void BroadcasterManager::Clear() { 460 std::lock_guard<std::recursive_mutex> guard(m_manager_mutex); 461 listener_collection::iterator end_iter = m_listeners.end(); 462 463 for (listener_collection::iterator iter = m_listeners.begin(); 464 iter != end_iter; iter++) 465 (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this()); 466 m_listeners.clear(); 467 m_event_map.clear(); 468 } 469