1//===-- ProcessFreeBSD.h ------------------------------------------*- C++ 2//-*-===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef liblldb_ProcessFreeBSD_H_ 11#define liblldb_ProcessFreeBSD_H_ 12 13#include "Plugins/Process/POSIX/ProcessMessage.h" 14#include "lldb/Target/Process.h" 15#include "lldb/Target/ThreadList.h" 16#include <mutex> 17#include <queue> 18#include <set> 19 20class ProcessMonitor; 21class FreeBSDThread; 22 23class ProcessFreeBSD : public lldb_private::Process { 24 25public: 26 // Static functions. 27 static lldb::ProcessSP 28 CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, 29 const lldb_private::FileSpec *crash_file_path); 30 31 static void Initialize(); 32 33 static void Terminate(); 34 35 static lldb_private::ConstString GetPluginNameStatic(); 36 37 static const char *GetPluginDescriptionStatic(); 38 39 // Constructors and destructors 40 ProcessFreeBSD(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, 41 lldb::UnixSignalsSP &unix_signals_sp); 42 43 ~ProcessFreeBSD(); 44 45 virtual lldb_private::Status WillResume() override; 46 47 // PluginInterface protocol 48 virtual lldb_private::ConstString GetPluginName() override; 49 50 virtual uint32_t GetPluginVersion() override; 51 52public: 53 // Process protocol. 54 void Finalize() override; 55 56 bool CanDebug(lldb::TargetSP target_sp, 57 bool plugin_specified_by_name) override; 58 59 lldb_private::Status WillLaunch(lldb_private::Module *module) override; 60 61 lldb_private::Status DoAttachToProcessWithID( 62 lldb::pid_t pid, 63 const lldb_private::ProcessAttachInfo &attach_info) override; 64 65 lldb_private::Status 66 DoLaunch(lldb_private::Module *exe_module, 67 lldb_private::ProcessLaunchInfo &launch_info) override; 68 69 void DidLaunch() override; 70 71 lldb_private::Status DoResume() override; 72 73 lldb_private::Status DoHalt(bool &caused_stop) override; 74 75 lldb_private::Status DoDetach(bool keep_stopped) override; 76 77 lldb_private::Status DoSignal(int signal) override; 78 79 lldb_private::Status DoDestroy() override; 80 81 void DoDidExec() override; 82 83 void RefreshStateAfterStop() override; 84 85 bool IsAlive() override; 86 87 size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size, 88 lldb_private::Status &error) override; 89 90 size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size, 91 lldb_private::Status &error) override; 92 93 lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions, 94 lldb_private::Status &error) override; 95 96 lldb_private::Status DoDeallocateMemory(lldb::addr_t ptr) override; 97 98 virtual size_t 99 GetSoftwareBreakpointTrapOpcode(lldb_private::BreakpointSite *bp_site); 100 101 lldb_private::Status 102 EnableBreakpointSite(lldb_private::BreakpointSite *bp_site) override; 103 104 lldb_private::Status 105 DisableBreakpointSite(lldb_private::BreakpointSite *bp_site) override; 106 107 lldb_private::Status EnableWatchpoint(lldb_private::Watchpoint *wp, 108 bool notify = true) override; 109 110 lldb_private::Status DisableWatchpoint(lldb_private::Watchpoint *wp, 111 bool notify = true) override; 112 113 lldb_private::Status GetWatchpointSupportInfo(uint32_t &num) override; 114 115 lldb_private::Status GetWatchpointSupportInfo(uint32_t &num, 116 bool &after) override; 117 118 virtual uint32_t UpdateThreadListIfNeeded(); 119 120 bool UpdateThreadList(lldb_private::ThreadList &old_thread_list, 121 lldb_private::ThreadList &new_thread_list) override; 122 123 virtual lldb::ByteOrder GetByteOrder() const; 124 125 lldb::addr_t GetImageInfoAddress() override; 126 127 size_t PutSTDIN(const char *buf, size_t len, 128 lldb_private::Status &error) override; 129 130 lldb_private::DataExtractor GetAuxvData() override; 131 132 // ProcessFreeBSD internal API. 133 134 /// Registers the given message with this process. 135 virtual void SendMessage(const ProcessMessage &message); 136 137 ProcessMonitor &GetMonitor() { 138 assert(m_monitor); 139 return *m_monitor; 140 } 141 142 lldb_private::FileSpec 143 GetFileSpec(const lldb_private::FileAction *file_action, 144 const lldb_private::FileSpec &default_file_spec, 145 const lldb_private::FileSpec &dbg_pts_file_spec); 146 147 /// Adds the thread to the list of threads for which we have received the 148 /// initial stopping signal. 149 /// The \p stop_tid parameter indicates the thread which the stop happened 150 /// for. 151 bool AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid); 152 153 bool WaitingForInitialStop(lldb::tid_t stop_tid); 154 155 virtual FreeBSDThread *CreateNewFreeBSDThread(lldb_private::Process &process, 156 lldb::tid_t tid); 157 158 static bool SingleStepBreakpointHit( 159 void *baton, lldb_private::StoppointCallbackContext *context, 160 lldb::user_id_t break_id, lldb::user_id_t break_loc_id); 161 162 lldb_private::Status SetupSoftwareSingleStepping(lldb::tid_t tid); 163 164 lldb_private::Status SetSoftwareSingleStepBreakpoint(lldb::tid_t tid, 165 lldb::addr_t addr); 166 167 bool IsSoftwareStepBreakpoint(lldb::tid_t tid); 168 169 bool SupportHardwareSingleStepping() const; 170 171 typedef std::vector<lldb::tid_t> tid_collection; 172 tid_collection &GetStepTids() { return m_step_tids; } 173 174protected: 175 static const size_t MAX_TRAP_OPCODE_SIZE = 8; 176 177 /// Target byte order. 178 lldb::ByteOrder m_byte_order; 179 180 /// Process monitor; 181 ProcessMonitor *m_monitor; 182 183 /// The module we are executing. 184 lldb_private::Module *m_module; 185 186 /// Message queue notifying this instance of inferior process state changes. 187 std::recursive_mutex m_message_mutex; 188 std::queue<ProcessMessage> m_message_queue; 189 190 /// Drive any exit events to completion. 191 bool m_exit_now; 192 193 /// Returns true if the process has exited. 194 bool HasExited(); 195 196 /// Returns true if the process is stopped. 197 bool IsStopped(); 198 199 /// Returns true if at least one running is currently running 200 bool IsAThreadRunning(); 201 202 typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap; 203 MMapMap m_addr_to_mmap_size; 204 205 typedef std::set<lldb::tid_t> ThreadStopSet; 206 /// Every thread begins with a stop signal. This keeps track 207 /// of the threads for which we have received the stop signal. 208 ThreadStopSet m_seen_initial_stop; 209 210 friend class FreeBSDThread; 211 212 tid_collection m_suspend_tids; 213 tid_collection m_run_tids; 214 tid_collection m_step_tids; 215 std::map<lldb::tid_t, lldb::break_id_t> m_threads_stepping_with_breakpoint; 216 217 int m_resume_signo; 218}; 219 220#endif // liblldb_ProcessFreeBSD_H_ 221