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