lldb/tools/debugserver/source/RNBContext.h

   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