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