lldb/source/Utility/Broadcaster.cpp

   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(uint32_t event_mask,
  54                                            bool include_primary) {
  55   llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
  56   size_t max_count = m_listeners.size();
  57   if (include_primary)
  58     max_count++;
  59   listeners.reserve(max_count);
  60
  61   for (auto it = m_listeners.begin(); it != m_listeners.end();) {
  62     lldb::ListenerSP curr_listener_sp(it->first.lock());
  63     if (curr_listener_sp) {
  64       if (it->second & event_mask)
  65         listeners.emplace_back(std::move(curr_listener_sp), it->second);
  66       ++it;
  67     } else
  68       // If our listener_wp didn't resolve, then we should remove this entry.
  69       it = m_listeners.erase(it);
  70   }
  71   if (include_primary && m_primary_listener_sp)
  72     listeners.emplace_back(m_primary_listener_sp, m_primary_listener_mask);
  73
  74   return listeners;
  75 }
  76
  77 bool Broadcaster::BroadcasterImpl::HasListeners(uint32_t event_mask) {
  78   if (m_primary_listener_sp)
  79     return true;
  80   for (auto it = m_listeners.begin(); it != m_listeners.end(); it++) {
  81     // Don't return a listener if the other end of the WP is gone:
  82     lldb::ListenerSP curr_listener_sp(it->first.lock());
  83     if (curr_listener_sp && (it->second & event_mask))
  84       return true;
  85   }
  86   return false;
  87 }
  88
  89 void Broadcaster::BroadcasterImpl::Clear() {
  90   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
  91
  92   // Make sure the listener forgets about this broadcaster. We do this in the
  93   // broadcaster in case the broadcaster object initiates the removal.
  94   for (auto &pair : GetListeners())
  95     pair.first->BroadcasterWillDestruct(&m_broadcaster);
  96
  97   m_listeners.clear();
  98   m_primary_listener_sp.reset();
  99 }
 100
 101 Broadcaster *Broadcaster::BroadcasterImpl::GetBroadcaster() {
 102   return &m_broadcaster;
 103 }
 104
 105 bool Broadcaster::BroadcasterImpl::GetEventNames(
 106     Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const {
 107   uint32_t num_names_added = 0;
 108   if (event_mask && !m_event_names.empty()) {
 109     event_names_map::const_iterator end = m_event_names.end();
 110     for (uint32_t bit = 1u, mask = event_mask; mask != 0 && bit != 0;
 111          bit <<= 1, mask >>= 1) {
 112       if (mask & 1) {
 113         event_names_map::const_iterator pos = m_event_names.find(bit);
 114         if (pos != end) {
 115           if (num_names_added > 0)
 116             s.PutCString(", ");
 117
 118           if (prefix_with_broadcaster_name) {
 119             s.PutCString(GetBroadcasterName());
 120             s.PutChar('.');
 121           }
 122           s.PutCString(pos->second);
 123           ++num_names_added;
 124         }
 125       }
 126     }
 127   }
 128   return num_names_added > 0;
 129 }
 130
 131 void Broadcaster::AddInitialEventsToListener(
 132     const lldb::ListenerSP &listener_sp, uint32_t requested_events) {}
 133
 134 uint32_t
 135 Broadcaster::BroadcasterImpl::AddListener(const lldb::ListenerSP &listener_sp,
 136                                           uint32_t event_mask) {
 137   if (!listener_sp)
 138     return 0;
 139
 140   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 141
 142   // See if we already have this listener, and if so, update its mask
 143
 144   bool handled = false;
 145
 146   if (listener_sp == m_primary_listener_sp)
 147     // This already handles all bits so just return the mask:
 148     return event_mask;
 149
 150   for (auto &pair : GetListeners(UINT32_MAX, false)) {
 151     if (pair.first == listener_sp) {
 152       handled = true;
 153       pair.second |= event_mask;
 154       m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
 155       break;
 156     }
 157   }
 158
 159   if (!handled) {
 160     // Grant a new listener the available event bits
 161     m_listeners.push_back(
 162         std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
 163
 164     // Individual broadcasters decide whether they have outstanding data when a
 165     // listener attaches, and insert it into the listener with this method.
 166     m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
 167   }
 168
 169   // Return the event bits that were granted to the listener
 170   return event_mask;
 171 }
 172
 173 bool Broadcaster::BroadcasterImpl::EventTypeHasListeners(uint32_t event_type) {
 174   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 175
 176   if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
 177     return true;
 178
 179   // The primary listener listens for all event bits:
 180   if (m_primary_listener_sp)
 181     return true;
 182
 183   return HasListeners(event_type);
 184 }
 185
 186 bool Broadcaster::BroadcasterImpl::RemoveListener(
 187     lldb_private::Listener *listener, uint32_t event_mask) {
 188   if (!listener)
 189     return false;
 190
 191   if (listener == m_primary_listener_sp.get()) {
 192     // Primary listeners listen for all the event bits for their broadcaster,
 193     // so remove this altogether if asked:
 194     m_primary_listener_sp.reset();
 195     return true;
 196   }
 197
 198   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 199   for (auto it = m_listeners.begin(); it != m_listeners.end();) {
 200     lldb::ListenerSP curr_listener_sp(it->first.lock());
 201
 202     if (!curr_listener_sp) {
 203       // The weak pointer for this listener didn't resolve, lets' prune it
 204       // as we go.
 205       m_listeners.erase(it);
 206       continue;
 207     }
 208
 209     if (curr_listener_sp.get() == listener) {
 210       it->second &= ~event_mask;
 211       // If we removed all the event bits from a listener, remove it from
 212       // the list as well.
 213       if (!it->second)
 214         m_listeners.erase(it);
 215       return true;
 216     } else
 217       it++;
 218   }
 219   return false;
 220 }
 221
 222 bool Broadcaster::BroadcasterImpl::RemoveListener(
 223     const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
 224   return RemoveListener(listener_sp.get(), event_mask);
 225 }
 226
 227 void Broadcaster::BroadcasterImpl::BroadcastEvent(EventSP &event_sp) {
 228   return PrivateBroadcastEvent(event_sp, false);
 229 }
 230
 231 void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(EventSP &event_sp) {
 232   return PrivateBroadcastEvent(event_sp, true);
 233 }
 234
 235 void Broadcaster::BroadcasterImpl::PrivateBroadcastEvent(EventSP &event_sp,
 236                                                          bool unique) {
 237   // Can't add a nullptr event...
 238   if (!event_sp)
 239     return;
 240
 241   // Update the broadcaster on this event
 242   event_sp->SetBroadcaster(&m_broadcaster);
 243
 244   const uint32_t event_type = event_sp->GetType();
 245
 246   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 247
 248   ListenerSP hijacking_listener_sp;
 249
 250   if (!m_hijacking_listeners.empty()) {
 251     assert(!m_hijacking_masks.empty());
 252     hijacking_listener_sp = m_hijacking_listeners.back();
 253     if ((event_type & m_hijacking_masks.back()) == 0)
 254       hijacking_listener_sp.reset();
 255   }
 256
 257   Log *log = GetLog(LLDBLog::Events);
 258   if (!log && event_sp->GetData())
 259     log = event_sp->GetData()->GetLogChannel();
 260
 261   if (log) {
 262     StreamString event_description;
 263     event_sp->Dump(&event_description);
 264     LLDB_LOG(log,
 265              "{0:x} Broadcaster(\"{1}\")::BroadcastEvent (event_sp = {2}, "
 266              "unique={3}) hijack = {4:x}",
 267              static_cast<void *>(this), GetBroadcasterName(),
 268              event_description.GetData(), unique,
 269              static_cast<void *>(hijacking_listener_sp.get()));
 270   }
 271   ListenerSP primary_listener_sp
 272       = hijacking_listener_sp ? hijacking_listener_sp : m_primary_listener_sp;
 273
 274   if (primary_listener_sp) {
 275     if (unique && primary_listener_sp->PeekAtNextEventForBroadcasterWithType(
 276                       &m_broadcaster, event_type))
 277       return;
 278     // Add the pending listeners but not if the event is hijacked, since that
 279     // is given sole access to the event stream it is hijacking.
 280     // Make sure to do this before adding the event to the primary or it might
 281     // start handling the event before we're done adding all the pending
 282     // listeners.
 283     if (!hijacking_listener_sp) {
 284       for (auto &pair : GetListeners(event_type, false)) {
 285         if (unique && pair.first->PeekAtNextEventForBroadcasterWithType(
 286                           &m_broadcaster, event_type))
 287           continue;
 288         event_sp->AddPendingListener(pair.first);
 289       }
 290     }
 291     primary_listener_sp->AddEvent(event_sp);
 292   } else {
 293     for (auto &pair : GetListeners(event_type)) {
 294       if (unique && pair.first->PeekAtNextEventForBroadcasterWithType(
 295                         &m_broadcaster, event_type))
 296         continue;
 297
 298       pair.first->AddEvent(event_sp);
 299     }
 300   }
 301 }
 302
 303 void Broadcaster::BroadcasterImpl::BroadcastEvent(uint32_t event_type,
 304                                                   EventData *event_data) {
 305   auto event_sp = std::make_shared<Event>(event_type, event_data);
 306   PrivateBroadcastEvent(event_sp, false);
 307 }
 308
 309 void Broadcaster::BroadcasterImpl::BroadcastEvent(
 310     uint32_t event_type, const lldb::EventDataSP &event_data_sp) {
 311   auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
 312   PrivateBroadcastEvent(event_sp, false);
 313 }
 314
 315 void Broadcaster::BroadcasterImpl::BroadcastEventIfUnique(
 316     uint32_t event_type, EventData *event_data) {
 317   auto event_sp = std::make_shared<Event>(event_type, event_data);
 318   PrivateBroadcastEvent(event_sp, true);
 319 }
 320
 321 void Broadcaster::BroadcasterImpl::SetPrimaryListener(lldb::ListenerSP
 322                                                       listener_sp) {
 323   // This might have already been added as a normal listener, make sure we
 324   // don't hold two copies.
 325   RemoveListener(listener_sp.get(), UINT32_MAX);
 326   m_primary_listener_sp = listener_sp;
 327
 328 }
 329
 330 bool Broadcaster::BroadcasterImpl::HijackBroadcaster(
 331     const lldb::ListenerSP &listener_sp, uint32_t event_mask) {
 332   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 333
 334   Log *log = GetLog(LLDBLog::Events);
 335   LLDB_LOG(
 336       log,
 337       "{0} Broadcaster(\"{1}\")::HijackBroadcaster (listener(\"{2}\")={3})",
 338       static_cast<void *>(this), GetBroadcasterName(),
 339       listener_sp->m_name.c_str(), static_cast<void *>(listener_sp.get()));
 340   m_hijacking_listeners.push_back(listener_sp);
 341   m_hijacking_masks.push_back(event_mask);
 342   return true;
 343 }
 344
 345 bool Broadcaster::BroadcasterImpl::IsHijackedForEvent(uint32_t event_mask) {
 346   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 347
 348   if (!m_hijacking_listeners.empty())
 349     return (event_mask & m_hijacking_masks.back()) != 0;
 350   return false;
 351 }
 352
 353 const char *Broadcaster::BroadcasterImpl::GetHijackingListenerName() {
 354   if (m_hijacking_listeners.size()) {
 355     return m_hijacking_listeners.back()->GetName();
 356   }
 357   return nullptr;
 358 }
 359
 360 void Broadcaster::BroadcasterImpl::RestoreBroadcaster() {
 361   std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 362
 363   if (!m_hijacking_listeners.empty()) {
 364     ListenerSP listener_sp = m_hijacking_listeners.back();
 365     Log *log = GetLog(LLDBLog::Events);
 366     LLDB_LOG(log,
 367              "{0} Broadcaster(\"{1}\")::RestoreBroadcaster (about to pop "
 368              "listener(\"{2}\")={3})",
 369              static_cast<void *>(this), GetBroadcasterName(),
 370              listener_sp->m_name.c_str(),
 371              static_cast<void *>(listener_sp.get()));
 372     m_hijacking_listeners.pop_back();
 373   }
 374   if (!m_hijacking_masks.empty())
 375     m_hijacking_masks.pop_back();
 376 }
 377
 378 ConstString &Broadcaster::GetBroadcasterClass() const {
 379   static ConstString class_name("lldb.anonymous");
 380   return class_name;
 381 }
 382
 383 bool BroadcastEventSpec::operator<(const BroadcastEventSpec &rhs) const {
 384   if (GetBroadcasterClass() == rhs.GetBroadcasterClass()) {
 385     return GetEventBits() < rhs.GetEventBits();
 386   }
 387   return GetBroadcasterClass() < rhs.GetBroadcasterClass();
 388 }
 389
 390 BroadcasterManager::BroadcasterManager() : m_manager_mutex() {}
 391
 392 lldb::BroadcasterManagerSP BroadcasterManager::MakeBroadcasterManager() {
 393   return lldb::BroadcasterManagerSP(new BroadcasterManager());
 394 }
 395
 396 uint32_t BroadcasterManager::RegisterListenerForEvents(
 397     const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) {
 398   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 399
 400   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
 401   uint32_t available_bits = event_spec.GetEventBits();
 402
 403   auto class_matches = [&event_spec](const event_listener_key &input) -> bool {
 404     return input.first.GetBroadcasterClass() ==
 405            event_spec.GetBroadcasterClass();
 406   };
 407
 408   while (iter != end_iter &&
 409          (iter = find_if(iter, end_iter, class_matches)) != end_iter) {
 410     available_bits &= ~((*iter).first.GetEventBits());
 411     iter++;
 412   }
 413
 414   if (available_bits != 0) {
 415     m_event_map.insert(event_listener_key(
 416         BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
 417         listener_sp));
 418     m_listeners.insert(listener_sp);
 419   }
 420
 421   return available_bits;
 422 }
 423
 424 bool BroadcasterManager::UnregisterListenerForEvents(
 425     const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) {
 426   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 427   bool removed_some = false;
 428
 429   if (m_listeners.erase(listener_sp) == 0)
 430     return false;
 431
 432   auto listener_matches_and_shared_bits =
 433       [&listener_sp, &event_spec](const event_listener_key &input) -> bool {
 434     return input.first.GetBroadcasterClass() ==
 435                event_spec.GetBroadcasterClass() &&
 436            (input.first.GetEventBits() & event_spec.GetEventBits()) != 0 &&
 437            input.second == listener_sp;
 438   };
 439   std::vector<BroadcastEventSpec> to_be_readded;
 440   uint32_t event_bits_to_remove = event_spec.GetEventBits();
 441
 442   // Go through the map and delete the exact matches, and build a list of
 443   // matches that weren't exact to re-add:
 444   for (auto iter = m_event_map.begin(), end = m_event_map.end();;) {
 445     iter = find_if(iter, end, listener_matches_and_shared_bits);
 446     if (iter == end)
 447       break;
 448     uint32_t iter_event_bits = (*iter).first.GetEventBits();
 449     removed_some = true;
 450
 451     if (event_bits_to_remove != iter_event_bits) {
 452       uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
 453       to_be_readded.emplace_back(event_spec.GetBroadcasterClass(),
 454                                  new_event_bits);
 455     }
 456     iter = m_event_map.erase(iter);
 457   }
 458
 459   // Okay now add back the bits that weren't completely removed:
 460   for (const auto &event : to_be_readded) {
 461     m_event_map.insert(event_listener_key(event, listener_sp));
 462   }
 463
 464   return removed_some;
 465 }
 466
 467 ListenerSP BroadcasterManager::GetListenerForEventSpec(
 468     const BroadcastEventSpec &event_spec) const {
 469   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 470
 471   auto event_spec_matches =
 472       [&event_spec](const event_listener_key &input) -> bool {
 473     return input.first.IsContainedIn(event_spec);
 474   };
 475
 476   auto iter = llvm::find_if(m_event_map, event_spec_matches);
 477   if (iter != m_event_map.end())
 478     return (*iter).second;
 479
 480   return nullptr;
 481 }
 482
 483 void BroadcasterManager::RemoveListener(Listener *listener) {
 484   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 485   auto listeners_predicate =
 486       [&listener](const lldb::ListenerSP &input) -> bool {
 487     return input.get() == listener;
 488   };
 489
 490   if (auto iter = llvm::find_if(m_listeners, listeners_predicate);
 491       iter != m_listeners.end())
 492     m_listeners.erase(iter);
 493
 494   auto events_predicate = [listener](const event_listener_key &input) -> bool {
 495     return input.second.get() == listener;
 496   };
 497
 498   // TODO: use 'std::map::erase_if' when moving to c++20.
 499   for (auto iter = m_event_map.begin(), end = m_event_map.end();;) {
 500     iter = find_if(iter, end, events_predicate);
 501     if (iter == end)
 502       break;
 503
 504     iter = m_event_map.erase(iter);
 505   }
 506 }
 507
 508 void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
 509   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 510
 511   auto listener_matches =
 512       [&listener_sp](const event_listener_key &input) -> bool {
 513     return input.second == listener_sp;
 514   };
 515
 516   if (m_listeners.erase(listener_sp) == 0)
 517     return;
 518
 519   // TODO: use 'std::map::erase_if' when moving to c++20.
 520   for (auto iter = m_event_map.begin(), end_iter = m_event_map.end();;) {
 521     iter = find_if(iter, end_iter, listener_matches);
 522     if (iter == end_iter)
 523       break;
 524
 525     iter = m_event_map.erase(iter);
 526   }
 527 }
 528
 529 void BroadcasterManager::SignUpListenersForBroadcaster(
 530     Broadcaster &broadcaster) {
 531   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 532
 533   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
 534
 535   auto class_matches = [&broadcaster](const event_listener_key &input) -> bool {
 536     return input.first.GetBroadcasterClass() ==
 537            broadcaster.GetBroadcasterClass();
 538   };
 539
 540   while (iter != end_iter &&
 541          (iter = find_if(iter, end_iter, class_matches)) != end_iter) {
 542     (*iter).second->StartListeningForEvents(&broadcaster,
 543                                             (*iter).first.GetEventBits());
 544     iter++;
 545   }
 546 }
 547
 548 void BroadcasterManager::Clear() {
 549   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 550
 551   for (auto &listener : m_listeners)
 552     listener->BroadcasterManagerWillDestruct(this->shared_from_this());
 553   m_listeners.clear();
 554   m_event_map.clear();
 555 }