contrib/llvm/tools/lldb/source/Core/Listener.cpp

   1 //===-- Listener.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Core/Listener.h"
  11
  12 #include "lldb/Core/Broadcaster.h"
  13 #include "lldb/Core/Event.h"
  14 #include "lldb/Utility/ConstString.h" // for ConstString
  15 #include "lldb/Utility/Log.h"
  16 #include "lldb/Utility/Logging.h" // for GetLogIfAllCategoriesSet, LIBL...
  17
  18 #include "llvm/ADT/Optional.h" // for Optional
  19
  20 #include <algorithm>
  21 #include <memory>  // for make_shared
  22 #include <utility> // for pair, make_pair
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 namespace {
  28 class BroadcasterManagerWPMatcher {
  29 public:
  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);
  35   }
  36
  37   BroadcasterManagerSP m_manager_sp;
  38 };
  39 } // anonymous namespace
  40
  41 Listener::Listener(const char *name)
  42     : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
  43       m_events_mutex() {
  44   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
  45   if (log != nullptr)
  46     log->Printf("%p Listener::Listener('%s')", static_cast<void *>(this),
  47                 m_name.c_str());
  48 }
  49
  50 Listener::~Listener() {
  51   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
  52
  53   Clear();
  54
  55   if (log)
  56     log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
  57                 __FUNCTION__, m_name.c_str());
  58 }
  59
  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());
  67     if (broadcaster_sp)
  68       broadcaster_sp->RemoveListener(this, pos->second.event_mask);
  69   }
  70   m_broadcasters.clear();
  71
  72   std::lock_guard<std::mutex> events_guard(m_events_mutex);
  73   m_events.clear();
  74   size_t num_managers = m_broadcaster_managers.size();
  75
  76   for (size_t i = 0; i < num_managers; i++) {
  77     BroadcasterManagerSP manager_sp(m_broadcaster_managers[i].lock());
  78     if (manager_sp)
  79       manager_sp->RemoveListener(this);
  80   }
  81
  82   if (log)
  83     log->Printf("%p Listener::%s('%s')", static_cast<void *>(this),
  84                 __FUNCTION__, m_name.c_str());
  85 }
  86
  87 uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
  88                                            uint32_t event_mask) {
  89   if (broadcaster) {
  90     // Scope for "locker"
  91     // Tell the broadcaster to add this object as a listener
  92     {
  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)));
  98     }
  99
 100     uint32_t acquired_mask =
 101         broadcaster->AddListener(this->shared_from_this(), event_mask);
 102
 103     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
 104     if (log != nullptr)
 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());
 109
 110     return acquired_mask;
 111   }
 112   return 0;
 113 }
 114
 115 uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
 116                                            uint32_t event_mask,
 117                                            HandleBroadcastCallback callback,
 118                                            void *callback_user_data) {
 119   if (broadcaster) {
 120     // Scope for "locker"
 121     // Tell the broadcaster to add this object as a listener
 122     {
 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)));
 128     }
 129
 130     uint32_t acquired_mask =
 131         broadcaster->AddListener(this->shared_from_this(), event_mask);
 132
 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());
 142     }
 143
 144     return acquired_mask;
 145   }
 146   return 0;
 147 }
 148
 149 bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
 150                                       uint32_t event_mask) {
 151   if (broadcaster) {
 152     // Scope for "locker"
 153     {
 154       std::lock_guard<std::recursive_mutex> broadcasters_guard(
 155           m_broadcasters_mutex);
 156       m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
 157     }
 158     // Remove the broadcaster from our set of broadcasters
 159     return broadcaster->RemoveListener(this->shared_from_this(), event_mask);
 160   }
 161
 162   return false;
 163 }
 164
 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"
 169   {
 170     std::lock_guard<std::recursive_mutex> broadcasters_guard(
 171         m_broadcasters_mutex);
 172     m_broadcasters.erase(broadcaster->GetBroadcasterImpl());
 173   }
 174
 175   // Scope for "event_locker"
 176   {
 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);
 183       else
 184         ++pos;
 185     }
 186   }
 187 }
 188
 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;
 194
 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);
 201 }
 202
 203 void Listener::AddEvent(EventSP &event_sp) {
 204   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
 205   if (log != nullptr)
 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()));
 209
 210   std::lock_guard<std::mutex> guard(m_events_mutex);
 211   m_events.push_back(event_sp);
 212   m_events_condition.notify_all();
 213 }
 214
 215 class EventBroadcasterMatches {
 216 public:
 217   EventBroadcasterMatches(Broadcaster *broadcaster)
 218       : m_broadcaster(broadcaster) {}
 219
 220   bool operator()(const EventSP &event_sp) const {
 221     return event_sp->BroadcasterIs(m_broadcaster);
 222   }
 223
 224 private:
 225   Broadcaster *m_broadcaster;
 226 };
 227
 228 class EventMatcher {
 229 public:
 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) {}
 235
 236   bool operator()(const EventSP &event_sp) const {
 237     if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
 238       return false;
 239
 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) {
 246           found_source = true;
 247           break;
 248         }
 249       }
 250       if (!found_source)
 251         return false;
 252     }
 253
 254     if (m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType())
 255       return true;
 256     return false;
 257   }
 258
 259 private:
 260   Broadcaster *m_broadcaster;
 261   const ConstString *m_broadcaster_names;
 262   const uint32_t m_num_broadcaster_names;
 263   const uint32_t m_event_type_mask;
 264 };
 265
 266 bool Listener::FindNextEventInternal(
 267     std::unique_lock<std::mutex> &lock,
 268     Broadcaster *broadcaster,             // nullptr for any broadcaster
 269     const ConstString *broadcaster_names, // nullptr for any event
 270     uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
 271     bool remove) {
 272   // NOTE: callers of this function must lock m_events_mutex using a
 273   // Mutex::Locker
 274   // and pass the locker as the first argument. m_events_mutex is no longer
 275   // recursive.
 276   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
 277
 278   if (m_events.empty())
 279     return false;
 280
 281   Listener::event_collection::iterator pos = m_events.end();
 282
 283   if (broadcaster == nullptr && broadcaster_names == nullptr &&
 284       event_type_mask == 0) {
 285     pos = m_events.begin();
 286   } else {
 287     pos = std::find_if(m_events.begin(), m_events.end(),
 288                        EventMatcher(broadcaster, broadcaster_names,
 289                                     num_broadcaster_names, event_type_mask));
 290   }
 291
 292   if (pos != m_events.end()) {
 293     event_sp = *pos;
 294
 295     if (log != nullptr)
 296       log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
 297                   "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
 298                   "remove=%i) event %p",
 299                   static_cast<void *>(this), GetName(),
 300                   static_cast<void *>(broadcaster),
 301                   static_cast<const void *>(broadcaster_names),
 302                   num_broadcaster_names, event_type_mask, remove,
 303                   static_cast<void *>(event_sp.get()));
 304
 305     if (remove) {
 306       m_events.erase(pos);
 307       // Unlock the event queue here.  We've removed this event and are about
 308       // to return it so it should be okay to get the next event off the queue
 309       // here - and it might be useful to do that in the "DoOnRemoval".
 310       lock.unlock();
 311       event_sp->DoOnRemoval();
 312     }
 313     return true;
 314   }
 315
 316   event_sp.reset();
 317   return false;
 318 }
 319
 320 Event *Listener::PeekAtNextEvent() {
 321   std::unique_lock<std::mutex> guard(m_events_mutex);
 322   EventSP event_sp;
 323   if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
 324     return event_sp.get();
 325   return nullptr;
 326 }
 327
 328 Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
 329   std::unique_lock<std::mutex> guard(m_events_mutex);
 330   EventSP event_sp;
 331   if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
 332     return event_sp.get();
 333   return nullptr;
 334 }
 335
 336 Event *
 337 Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
 338                                                 uint32_t event_type_mask) {
 339   std::unique_lock<std::mutex> guard(m_events_mutex);
 340   EventSP event_sp;
 341   if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
 342                             event_sp, false))
 343     return event_sp.get();
 344   return nullptr;
 345 }
 346
 347 bool Listener::GetEventInternal(
 348     const Timeout<std::micro> &timeout,
 349     Broadcaster *broadcaster,             // nullptr for any broadcaster
 350     const ConstString *broadcaster_names, // nullptr for any event
 351     uint32_t num_broadcaster_names, uint32_t event_type_mask,
 352     EventSP &event_sp) {
 353   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
 354   LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
 355
 356   std::unique_lock<std::mutex> lock(m_events_mutex);
 357
 358   while (true) {
 359     if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
 360                               num_broadcaster_names, event_type_mask, event_sp,
 361                               true)) {
 362       return true;
 363     } else {
 364       std::cv_status result = std::cv_status::no_timeout;
 365       if (!timeout)
 366         m_events_condition.wait(lock);
 367       else
 368         result = m_events_condition.wait_for(lock, *timeout);
 369
 370       if (result == std::cv_status::timeout) {
 371         log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
 372         if (log)
 373           log->Printf("%p Listener::GetEventInternal() timed out for %s",
 374                       static_cast<void *>(this), m_name.c_str());
 375         return false;
 376       } else if (result != std::cv_status::no_timeout) {
 377         log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
 378         if (log)
 379           log->Printf("%p Listener::GetEventInternal() unknown error for %s",
 380                       static_cast<void *>(this), m_name.c_str());
 381         return false;
 382       }
 383     }
 384   }
 385
 386   return false;
 387 }
 388
 389 bool Listener::GetEventForBroadcasterWithType(
 390     Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
 391     const Timeout<std::micro> &timeout) {
 392   return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
 393                           event_sp);
 394 }
 395
 396 bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
 397                                       EventSP &event_sp,
 398                                       const Timeout<std::micro> &timeout) {
 399   return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
 400 }
 401
 402 bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
 403   return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
 404 }
 405
 406 size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
 407   size_t num_handled = 0;
 408   std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
 409   Broadcaster *broadcaster = event_sp->GetBroadcaster();
 410   if (!broadcaster)
 411     return 0;
 412   broadcaster_collection::iterator pos;
 413   broadcaster_collection::iterator end = m_broadcasters.end();
 414   Broadcaster::BroadcasterImplSP broadcaster_impl_sp(
 415       broadcaster->GetBroadcasterImpl());
 416   for (pos = m_broadcasters.find(broadcaster_impl_sp);
 417        pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
 418     BroadcasterInfo info = pos->second;
 419     if (event_sp->GetType() & info.event_mask) {
 420       if (info.callback != nullptr) {
 421         info.callback(event_sp, info.callback_user_data);
 422         ++num_handled;
 423       }
 424     }
 425   }
 426   return num_handled;
 427 }
 428
 429 uint32_t
 430 Listener::StartListeningForEventSpec(BroadcasterManagerSP manager_sp,
 431                                      const BroadcastEventSpec &event_spec) {
 432   if (!manager_sp)
 433     return 0;
 434
 435   // The BroadcasterManager mutex must be locked before m_broadcasters_mutex to
 436   // avoid violating the lock hierarchy (manager before broadcasters).
 437   std::lock_guard<std::recursive_mutex> manager_guard(
 438       manager_sp->m_manager_mutex);
 439   std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
 440
 441   uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
 442       this->shared_from_this(), event_spec);
 443   if (bits_acquired) {
 444     broadcaster_manager_collection::iterator iter,
 445         end_iter = m_broadcaster_managers.end();
 446     BroadcasterManagerWP manager_wp(manager_sp);
 447     BroadcasterManagerWPMatcher matcher(manager_sp);
 448     iter = std::find_if<broadcaster_manager_collection::iterator,
 449                         BroadcasterManagerWPMatcher>(
 450         m_broadcaster_managers.begin(), end_iter, matcher);
 451     if (iter == end_iter)
 452       m_broadcaster_managers.push_back(manager_wp);
 453   }
 454
 455   return bits_acquired;
 456 }
 457
 458 bool Listener::StopListeningForEventSpec(BroadcasterManagerSP manager_sp,
 459                                          const BroadcastEventSpec &event_spec) {
 460   if (!manager_sp)
 461     return false;
 462
 463   std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
 464   return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
 465                                                  event_spec);
 466 }
 467
 468 ListenerSP Listener::MakeListener(const char *name) {
 469   return ListenerSP(new Listener(name));
 470 }