1 //===-- RNBContext.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 //  Created by Greg Clayton on 12/12/07.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_RNBCONTEXT_H
14 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_RNBCONTEXT_H
15 
16 #include "DNBError.h"
17 #include "PThreadEvent.h"
18 #include "RNBDefs.h"
19 #include <string>
20 #include <vector>
21 
22 class RNBContext {
23 public:
24   using IgnoredExceptions = std::vector<exception_mask_t>;
25   enum {
26     event_proc_state_changed = 0x001,
27     event_proc_thread_running = 0x002, // Sticky
28     event_proc_thread_exiting = 0x004,
29     event_proc_stdio_available = 0x008,
30     event_proc_profile_data = 0x010,
31     event_read_packet_available = 0x020,
32     event_read_thread_running = 0x040, // Sticky
33     event_read_thread_exiting = 0x080,
34 
35     normal_event_bits = event_proc_state_changed | event_proc_thread_exiting |
36                         event_proc_stdio_available | event_proc_profile_data |
37                         event_read_packet_available |
38                         event_read_thread_exiting ,
39 
40     sticky_event_bits = event_proc_thread_running | event_read_thread_running,
41 
42     all_event_bits = sticky_event_bits | normal_event_bits
43   } event_t;
44   // Constructors and Destructors
45   RNBContext() = default;
46   virtual ~RNBContext();
47 
ProcessID()48   nub_process_t ProcessID() const { return m_pid; }
HasValidProcessID()49   bool HasValidProcessID() const { return m_pid != INVALID_NUB_PROCESS; }
50   void SetProcessID(nub_process_t pid);
GetProcessStopCount()51   nub_size_t GetProcessStopCount() const { return m_pid_stop_count; }
SetProcessStopCount(nub_size_t count)52   bool SetProcessStopCount(nub_size_t count) {
53     // Returns true if this class' notion of the PID state changed
54     if (m_pid_stop_count == count)
55       return false; // Didn't change
56     m_pid_stop_count = count;
57     return true; // The stop count has changed.
58   }
59 
60   bool ProcessStateRunning() const;
Events()61   PThreadEvent &Events() { return m_events; }
AllEventBits()62   nub_event_t AllEventBits() const { return all_event_bits; }
NormalEventBits()63   nub_event_t NormalEventBits() const { return normal_event_bits; }
StickyEventBits()64   nub_event_t StickyEventBits() const { return sticky_event_bits; }
65   const char *EventsAsString(nub_event_t events, std::string &s);
66 
ArgumentCount()67   size_t ArgumentCount() const { return m_arg_vec.size(); }
68   const char *ArgumentAtIndex(size_t index);
PushArgument(const char * arg)69   void PushArgument(const char *arg) {
70     if (arg)
71       m_arg_vec.push_back(arg);
72   }
ClearArgv()73   void ClearArgv() { m_arg_vec.erase(m_arg_vec.begin(), m_arg_vec.end()); }
74 
EnvironmentCount()75   size_t EnvironmentCount() const { return m_env_vec.size(); }
76   const char *EnvironmentAtIndex(size_t index);
PushEnvironment(const char * arg)77   void PushEnvironment(const char *arg) {
78     if (arg)
79       m_env_vec.push_back(arg);
80   }
81   void PushEnvironmentIfNeeded(const char *arg);
ClearEnvironment()82   void ClearEnvironment() {
83     m_env_vec.erase(m_env_vec.begin(), m_env_vec.end());
84   }
LaunchStatus()85   DNBError &LaunchStatus() { return m_launch_status; }
86   const char *LaunchStatusAsString(std::string &s);
LaunchFlavor()87   nub_launch_flavor_t LaunchFlavor() const { return m_launch_flavor; }
SetLaunchFlavor(nub_launch_flavor_t flavor)88   void SetLaunchFlavor(nub_launch_flavor_t flavor) { m_launch_flavor = flavor; }
89 
GetWorkingDirectory()90   const char *GetWorkingDirectory() const {
91     if (!m_working_directory.empty())
92       return m_working_directory.c_str();
93     return NULL;
94   }
95 
96   bool SetWorkingDirectory(const char *path);
97 
GetSTDIN()98   std::string &GetSTDIN() { return m_stdin; }
GetSTDOUT()99   std::string &GetSTDOUT() { return m_stdout; }
GetSTDERR()100   std::string &GetSTDERR() { return m_stderr; }
GetWorkingDir()101   std::string &GetWorkingDir() { return m_working_dir; }
102 
GetSTDINPath()103   const char *GetSTDINPath() {
104     return m_stdin.empty() ? NULL : m_stdin.c_str();
105   }
GetSTDOUTPath()106   const char *GetSTDOUTPath() {
107     return m_stdout.empty() ? NULL : m_stdout.c_str();
108   }
GetSTDERRPath()109   const char *GetSTDERRPath() {
110     return m_stderr.empty() ? NULL : m_stderr.c_str();
111   }
GetWorkingDirPath()112   const char *GetWorkingDirPath() {
113     return m_working_dir.empty() ? NULL : m_working_dir.c_str();
114   }
115 
PushProcessEvent(const char * p)116   void PushProcessEvent(const char *p) { m_process_event.assign(p); }
GetProcessEvent()117   const char *GetProcessEvent() { return m_process_event.c_str(); }
118 
SetDetachOnError(bool detach)119   void SetDetachOnError(bool detach) { m_detach_on_error = detach; }
GetDetachOnError()120   bool GetDetachOnError() { return m_detach_on_error; }
121 
122   bool AddIgnoredException(const char *exception_name);
123 
124   void AddDefaultIgnoredExceptions();
125 
GetIgnoredExceptions()126   const IgnoredExceptions &GetIgnoredExceptions() {
127     return m_ignored_exceptions;
128   }
129 
130 protected:
131   // Classes that inherit from RNBContext can see and modify these
132   nub_process_t m_pid = INVALID_NUB_PROCESS;
133   std::string m_stdin;
134   std::string m_stdout;
135   std::string m_stderr;
136   std::string m_working_dir;
137   nub_size_t m_pid_stop_count = 0;
138   /// Threaded events that we can wait for.
139   PThreadEvent m_events{0, all_event_bits};
140   pthread_t m_pid_pthread;
141   /// How to launch our inferior process.
142   nub_launch_flavor_t m_launch_flavor = eLaunchFlavorDefault;
143   /// This holds the status from the last launch attempt.
144   DNBError m_launch_status;
145   std::vector<std::string> m_arg_vec;
146   /// This will be unparsed entries FOO=value
147   std::vector<std::string> m_env_vec;
148   std::string m_working_directory;
149   std::string m_process_event;
150   bool m_detach_on_error = false;
151   IgnoredExceptions m_ignored_exceptions;
152 
153   void StartProcessStatusThread();
154   void StopProcessStatusThread();
155   static void *ThreadFunctionProcessStatus(void *arg);
156 
157 private:
158   RNBContext(const RNBContext &rhs) = delete;
159   RNBContext &operator=(const RNBContext &rhs) = delete;
160 };
161 
162 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_RNBCONTEXT_H
163