contrib/llvm/tools/lldb/source/Host/common/MainLoop.cpp

   1 //===-- MainLoop.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 "llvm/Config/llvm-config.h"
  11
  12 #include "lldb/Host/MainLoop.h"
  13 #include "lldb/Utility/Error.h"
  14 #include <algorithm>
  15 #include <cassert>
  16 #include <cerrno>
  17 #include <csignal>
  18 #include <vector>
  19 #include <time.h>
  20
  21 // Multiplexing is implemented using kqueue on systems that support it (BSD
  22 // variants including OSX). On linux we use ppoll, while android uses pselect
  23 // (ppoll is present but not implemented properly). On windows we use WSApoll
  24 // (which does not support signals).
  25
  26 #if HAVE_SYS_EVENT_H
  27 #include <sys/event.h>
  28 #elif defined(LLVM_ON_WIN32)
  29 #include <winsock2.h>
  30 #else
  31 #include <poll.h>
  32 #endif
  33
  34 #ifdef LLVM_ON_WIN32
  35 #define POLL WSAPoll
  36 #else
  37 #define POLL poll
  38 #endif
  39
  40 #ifdef __ANDROID__
  41 #define FORCE_PSELECT
  42 #endif
  43
  44 #if SIGNAL_POLLING_UNSUPPORTED
  45 #ifdef LLVM_ON_WIN32
  46 typedef int sigset_t;
  47 typedef int siginfo_t;
  48 #endif
  49
  50 int ppoll(struct pollfd *fds, size_t nfds, const struct timespec *timeout_ts,
  51           const sigset_t *) {
  52   int timeout =
  53       (timeout_ts == nullptr)
  54           ? -1
  55           : (timeout_ts->tv_sec * 1000 + timeout_ts->tv_nsec / 1000000);
  56   return POLL(fds, nfds, timeout);
  57 }
  58
  59 #endif
  60
  61 using namespace lldb;
  62 using namespace lldb_private;
  63
  64 static sig_atomic_t g_signal_flags[NSIG];
  65
  66 static void SignalHandler(int signo, siginfo_t *info, void *) {
  67   assert(signo < NSIG);
  68   g_signal_flags[signo] = 1;
  69 }
  70
  71 class MainLoop::RunImpl {
  72 public:
  73   RunImpl(MainLoop &loop);
  74   ~RunImpl() = default;
  75
  76   Error Poll();
  77   void ProcessEvents();
  78
  79 private:
  80   MainLoop &loop;
  81
  82 #if HAVE_SYS_EVENT_H
  83   std::vector<struct kevent> in_events;
  84   struct kevent out_events[4];
  85   int num_events = -1;
  86
  87 #else
  88 #ifdef FORCE_PSELECT
  89   fd_set read_fd_set;
  90 #else
  91   std::vector<struct pollfd> read_fds;
  92 #endif
  93
  94   sigset_t get_sigmask();
  95 #endif
  96 };
  97
  98 #if HAVE_SYS_EVENT_H
  99 MainLoop::RunImpl::RunImpl(MainLoop &loop) : loop(loop) {
 100   in_events.reserve(loop.m_read_fds.size());
 101 }
 102
 103 Error MainLoop::RunImpl::Poll() {
 104   in_events.resize(loop.m_read_fds.size());
 105   unsigned i = 0;
 106   for (auto &fd : loop.m_read_fds)
 107     EV_SET(&in_events[i++], fd.first, EVFILT_READ, EV_ADD, 0, 0, 0);
 108
 109   num_events = kevent(loop.m_kqueue, in_events.data(), in_events.size(),
 110                       out_events, llvm::array_lengthof(out_events), nullptr);
 111
 112   if (num_events < 0)
 113     return Error("kevent() failed with error %d\n", num_events);
 114   return Error();
 115 }
 116
 117 void MainLoop::RunImpl::ProcessEvents() {
 118   assert(num_events >= 0);
 119   for (int i = 0; i < num_events; ++i) {
 120     if (loop.m_terminate_request)
 121       return;
 122     switch (out_events[i].filter) {
 123     case EVFILT_READ:
 124       loop.ProcessReadObject(out_events[i].ident);
 125       break;
 126     case EVFILT_SIGNAL:
 127       loop.ProcessSignal(out_events[i].ident);
 128       break;
 129     default:
 130       llvm_unreachable("Unknown event");
 131     }
 132   }
 133 }
 134 #else
 135 MainLoop::RunImpl::RunImpl(MainLoop &loop) : loop(loop) {
 136 #ifndef FORCE_PSELECT
 137   read_fds.reserve(loop.m_read_fds.size());
 138 #endif
 139 }
 140
 141 sigset_t MainLoop::RunImpl::get_sigmask() {
 142 #if SIGNAL_POLLING_UNSUPPORTED
 143   return 0;
 144 #else
 145   sigset_t sigmask;
 146   int ret = pthread_sigmask(SIG_SETMASK, nullptr, &sigmask);
 147   assert(ret == 0);
 148   (void) ret;
 149
 150   for (const auto &sig : loop.m_signals)
 151     sigdelset(&sigmask, sig.first);
 152   return sigmask;
 153 #endif
 154 }
 155
 156 #ifdef FORCE_PSELECT
 157 Error MainLoop::RunImpl::Poll() {
 158   FD_ZERO(&read_fd_set);
 159   int nfds = 0;
 160   for (const auto &fd : loop.m_read_fds) {
 161     FD_SET(fd.first, &read_fd_set);
 162     nfds = std::max(nfds, fd.first + 1);
 163   }
 164
 165   sigset_t sigmask = get_sigmask();
 166   if (pselect(nfds, &read_fd_set, nullptr, nullptr, nullptr, &sigmask) == -1 &&
 167       errno != EINTR)
 168     return Error(errno, eErrorTypePOSIX);
 169
 170   return Error();
 171 }
 172 #else
 173 Error MainLoop::RunImpl::Poll() {
 174   read_fds.clear();
 175
 176   sigset_t sigmask = get_sigmask();
 177
 178   for (const auto &fd : loop.m_read_fds) {
 179     struct pollfd pfd;
 180     pfd.fd = fd.first;
 181     pfd.events = POLLIN;
 182     pfd.revents = 0;
 183     read_fds.push_back(pfd);
 184   }
 185
 186   if (ppoll(read_fds.data(), read_fds.size(), nullptr, &sigmask) == -1 &&
 187       errno != EINTR)
 188     return Error(errno, eErrorTypePOSIX);
 189
 190   return Error();
 191 }
 192 #endif
 193
 194 void MainLoop::RunImpl::ProcessEvents() {
 195 #ifdef FORCE_PSELECT
 196   for (const auto &fd : loop.m_read_fds) {
 197     if (!FD_ISSET(fd.first, &read_fd_set))
 198       continue;
 199     IOObject::WaitableHandle handle = fd.first;
 200 #else
 201   for (const auto &fd : read_fds) {
 202     if ((fd.revents & POLLIN) == 0)
 203       continue;
 204     IOObject::WaitableHandle handle = fd.fd;
 205 #endif
 206     if (loop.m_terminate_request)
 207       return;
 208
 209     loop.ProcessReadObject(handle);
 210   }
 211
 212   for (const auto &entry : loop.m_signals) {
 213     if (loop.m_terminate_request)
 214       return;
 215     if (g_signal_flags[entry.first] == 0)
 216       continue; // No signal
 217     g_signal_flags[entry.first] = 0;
 218     loop.ProcessSignal(entry.first);
 219   }
 220 }
 221 #endif
 222
 223 MainLoop::MainLoop() {
 224 #if HAVE_SYS_EVENT_H
 225   m_kqueue = kqueue();
 226   assert(m_kqueue >= 0);
 227 #endif
 228 }
 229 MainLoop::~MainLoop() {
 230 #if HAVE_SYS_EVENT_H
 231   close(m_kqueue);
 232 #endif
 233   assert(m_read_fds.size() == 0);
 234   assert(m_signals.size() == 0);
 235 }
 236
 237 MainLoop::ReadHandleUP
 238 MainLoop::RegisterReadObject(const IOObjectSP &object_sp,
 239                                   const Callback &callback, Error &error) {
 240 #ifdef LLVM_ON_WIN32
 241   if (object_sp->GetFdType() != IOObject:: eFDTypeSocket) {
 242     error.SetErrorString("MainLoop: non-socket types unsupported on Windows");
 243     return nullptr;
 244   }
 245 #endif
 246   if (!object_sp || !object_sp->IsValid()) {
 247     error.SetErrorString("IO object is not valid.");
 248     return nullptr;
 249   }
 250
 251   const bool inserted =
 252       m_read_fds.insert({object_sp->GetWaitableHandle(), callback}).second;
 253   if (!inserted) {
 254     error.SetErrorStringWithFormat("File descriptor %d already monitored.",
 255                                    object_sp->GetWaitableHandle());
 256     return nullptr;
 257   }
 258
 259   return CreateReadHandle(object_sp);
 260 }
 261
 262 // We shall block the signal, then install the signal handler. The signal will
 263 // be unblocked in
 264 // the Run() function to check for signal delivery.
 265 MainLoop::SignalHandleUP
 266 MainLoop::RegisterSignal(int signo, const Callback &callback,
 267                               Error &error) {
 268 #ifdef SIGNAL_POLLING_UNSUPPORTED
 269   error.SetErrorString("Signal polling is not supported on this platform.");
 270   return nullptr;
 271 #else
 272   if (m_signals.find(signo) != m_signals.end()) {
 273     error.SetErrorStringWithFormat("Signal %d already monitored.", signo);
 274     return nullptr;
 275   }
 276
 277   SignalInfo info;
 278   info.callback = callback;
 279   struct sigaction new_action;
 280   new_action.sa_sigaction = &SignalHandler;
 281   new_action.sa_flags = SA_SIGINFO;
 282   sigemptyset(&new_action.sa_mask);
 283   sigaddset(&new_action.sa_mask, signo);
 284   sigset_t old_set;
 285
 286   g_signal_flags[signo] = 0;
 287
 288   // Even if using kqueue, the signal handler will still be invoked, so it's
 289   // important to replace it with our "bening" handler.
 290   int ret = sigaction(signo, &new_action, &info.old_action);
 291   assert(ret == 0 && "sigaction failed");
 292
 293 #if HAVE_SYS_EVENT_H
 294   struct kevent ev;
 295   EV_SET(&ev, signo, EVFILT_SIGNAL, EV_ADD, 0, 0, 0);
 296   ret = kevent(m_kqueue, &ev, 1, nullptr, 0, nullptr);
 297   assert(ret == 0);
 298 #endif
 299
 300   // If we're using kqueue, the signal needs to be unblocked in order to recieve
 301   // it. If using pselect/ppoll, we need to block it, and later unblock it as a
 302   // part of the system call.
 303   ret = pthread_sigmask(HAVE_SYS_EVENT_H ? SIG_UNBLOCK : SIG_BLOCK,
 304                         &new_action.sa_mask, &old_set);
 305   assert(ret == 0 && "pthread_sigmask failed");
 306   info.was_blocked = sigismember(&old_set, signo);
 307   m_signals.insert({signo, info});
 308
 309   return SignalHandleUP(new SignalHandle(*this, signo));
 310 #endif
 311 }
 312
 313 void MainLoop::UnregisterReadObject(IOObject::WaitableHandle handle) {
 314   bool erased = m_read_fds.erase(handle);
 315   UNUSED_IF_ASSERT_DISABLED(erased);
 316   assert(erased);
 317 }
 318
 319 void MainLoop::UnregisterSignal(int signo) {
 320 #if SIGNAL_POLLING_UNSUPPORTED
 321   Error("Signal polling is not supported on this platform.");
 322 #else
 323   auto it = m_signals.find(signo);
 324   assert(it != m_signals.end());
 325
 326   sigaction(signo, &it->second.old_action, nullptr);
 327
 328   sigset_t set;
 329   sigemptyset(&set);
 330   sigaddset(&set, signo);
 331   int ret = pthread_sigmask(it->second.was_blocked ? SIG_BLOCK : SIG_UNBLOCK,
 332                             &set, nullptr);
 333   assert(ret == 0);
 334   (void)ret;
 335
 336 #if HAVE_SYS_EVENT_H
 337   struct kevent ev;
 338   EV_SET(&ev, signo, EVFILT_SIGNAL, EV_DELETE, 0, 0, 0);
 339   ret = kevent(m_kqueue, &ev, 1, nullptr, 0, nullptr);
 340   assert(ret == 0);
 341 #endif
 342
 343   m_signals.erase(it);
 344 #endif
 345 }
 346
 347 Error MainLoop::Run() {
 348   m_terminate_request = false;
 349
 350   Error error;
 351   RunImpl impl(*this);
 352
 353   // run until termination or until we run out of things to listen to
 354   while (!m_terminate_request && (!m_read_fds.empty() || !m_signals.empty())) {
 355
 356     error = impl.Poll();
 357     if (error.Fail())
 358       return error;
 359
 360     impl.ProcessEvents();
 361
 362     if (m_terminate_request)
 363       return Error();
 364   }
 365   return Error();
 366 }
 367
 368 void MainLoop::ProcessSignal(int signo) {
 369   auto it = m_signals.find(signo);
 370   if (it != m_signals.end())
 371     it->second.callback(*this); // Do the work
 372 }
 373
 374 void MainLoop::ProcessReadObject(IOObject::WaitableHandle handle) {
 375   auto it = m_read_fds.find(handle);
 376   if (it != m_read_fds.end())
 377     it->second(*this); // Do the work
 378 }