1 //===-- MainLoop.h ----------------------------------------------*- 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 #ifndef LLDB_HOST_MAINLOOP_H
10 #define LLDB_HOST_MAINLOOP_H
11 
12 #include "lldb/Host/Config.h"
13 #include "lldb/Host/MainLoopBase.h"
14 #include "llvm/ADT/DenseMap.h"
15 #include <csignal>
16 #include <list>
17 
18 #if !HAVE_PPOLL && !HAVE_SYS_EVENT_H && !defined(__ANDROID__)
19 #define SIGNAL_POLLING_UNSUPPORTED 1
20 #endif
21 
22 namespace lldb_private {
23 
24 // Implementation of the MainLoopBase class. It can monitor file descriptors
25 // for readability using ppoll, kqueue, poll or WSAPoll. On Windows it only
26 // supports polling sockets, and will not work on generic file handles or
27 // pipes. On systems without kqueue or ppoll handling singnals is not
28 // supported. In addition to the common base, this class provides the ability
29 // to invoke a given handler when a signal is received.
30 //
31 // Since this class is primarily intended to be used for single-threaded
32 // processing, it does not attempt to perform any internal synchronisation and
33 // any concurrent accesses must be protected  externally. However, it is
34 // perfectly legitimate to have more than one instance of this class running on
35 // separate threads, or even a single thread (with some limitations on signal
36 // monitoring).
37 // TODO: Add locking if this class is to be used in a multi-threaded context.
38 class MainLoop : public MainLoopBase {
39 private:
40   class SignalHandle;
41 
42 public:
43   typedef std::unique_ptr<SignalHandle> SignalHandleUP;
44 
45   MainLoop();
46   ~MainLoop() override;
47 
48   ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
49                                   const Callback &callback,
50                                   Status &error) override;
51 
52   // Listening for signals from multiple MainLoop instances is perfectly safe
53   // as long as they don't try to listen for the same signal. The callback
54   // function is invoked when the control returns to the Run() function, not
55   // when the hander is executed. This mean that you can treat the callback as
56   // a normal function and perform things which would not be safe in a signal
57   // handler. However, since the callback is not invoked synchronously, you
58   // cannot use this mechanism to handle SIGSEGV and the like.
59   SignalHandleUP RegisterSignal(int signo, const Callback &callback,
60                                 Status &error);
61 
62   Status Run() override;
63 
64   // This should only be performed from a callback. Do not attempt to terminate
65   // the processing from another thread.
66   // TODO: Add synchronization if we want to be terminated from another thread.
67   void RequestTermination() override { m_terminate_request = true; }
68 
69 protected:
70   void UnregisterReadObject(IOObject::WaitableHandle handle) override;
71 
72   void UnregisterSignal(int signo, std::list<Callback>::iterator callback_it);
73 
74 private:
75   void ProcessReadObject(IOObject::WaitableHandle handle);
76   void ProcessSignal(int signo);
77 
78   class SignalHandle {
79   public:
80     ~SignalHandle() { m_mainloop.UnregisterSignal(m_signo, m_callback_it); }
81 
82   private:
83     SignalHandle(MainLoop &mainloop, int signo,
84                  std::list<Callback>::iterator callback_it)
85         : m_mainloop(mainloop), m_signo(signo), m_callback_it(callback_it) {}
86 
87     MainLoop &m_mainloop;
88     int m_signo;
89     std::list<Callback>::iterator m_callback_it;
90 
91     friend class MainLoop;
92     SignalHandle(const SignalHandle &) = delete;
93     const SignalHandle &operator=(const SignalHandle &) = delete;
94   };
95 
96   struct SignalInfo {
97     std::list<Callback> callbacks;
98 #ifndef SIGNAL_POLLING_UNSUPPORTED
99     struct sigaction old_action;
100 #endif
101     bool was_blocked : 1;
102   };
103   class RunImpl;
104 
105   llvm::DenseMap<IOObject::WaitableHandle, Callback> m_read_fds;
106   llvm::DenseMap<int, SignalInfo> m_signals;
107 #if HAVE_SYS_EVENT_H
108   int m_kqueue;
109 #endif
110   bool m_terminate_request : 1;
111 };
112 
113 } // namespace lldb_private
114 
115 #endif // LLDB_HOST_MAINLOOP_H
116