285 lines · c
1//===-- NativeProcessLinux.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-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef liblldb_NativeProcessLinux_H_10#define liblldb_NativeProcessLinux_H_11 12#include <csignal>13#include <unordered_set>14 15#include "lldb/Host/Debug.h"16#include "lldb/Host/HostThread.h"17#include "lldb/Host/linux/Support.h"18#include "lldb/Host/posix/Support.h"19#include "lldb/Target/MemoryRegionInfo.h"20#include "lldb/Utility/ArchSpec.h"21#include "lldb/Utility/FileSpec.h"22#include "lldb/lldb-types.h"23#include "llvm/ADT/SmallPtrSet.h"24 25#include "IntelPTCollector.h"26#include "NativeThreadLinux.h"27#include "Plugins/Process/POSIX/NativeProcessELF.h"28#include "Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h"29 30namespace lldb_private {31class Status;32class Scalar;33 34namespace process_linux {35/// \class NativeProcessLinux36/// Manages communication with the inferior (debugee) process.37///38/// Upon construction, this class prepares and launches an inferior process39/// for debugging.40///41/// Changes in the inferior process state are broadcasted.42class NativeProcessLinux : public NativeProcessELF,43 private NativeProcessSoftwareSingleStep {44public:45 class Manager : public NativeProcessProtocol::Manager {46 public:47 Manager(MainLoop &mainloop);48 49 llvm::Expected<std::unique_ptr<NativeProcessProtocol>>50 Launch(ProcessLaunchInfo &launch_info,51 NativeDelegate &native_delegate) override;52 53 llvm::Expected<std::unique_ptr<NativeProcessProtocol>>54 Attach(lldb::pid_t pid, NativeDelegate &native_delegate) override;55 56 Extension GetSupportedExtensions() const override;57 58 void AddProcess(NativeProcessLinux &process) {59 m_processes.insert(&process);60 }61 62 void RemoveProcess(NativeProcessLinux &process) {63 m_processes.erase(&process);64 }65 66 // Collect an event for the given tid, waiting for it if necessary.67 void CollectThread(::pid_t tid);68 69 private:70 MainLoop::SignalHandleUP m_sigchld_handle;71 72 llvm::SmallPtrSet<NativeProcessLinux *, 2> m_processes;73 74 // Threads (events) which haven't been claimed by any process.75 llvm::DenseSet<::pid_t> m_unowned_threads;76 77 void SigchldHandler();78 };79 80 // NativeProcessProtocol Interface81 82 ~NativeProcessLinux() override { m_manager.RemoveProcess(*this); }83 84 Status Resume(const ResumeActionList &resume_actions) override;85 86 Status Halt() override;87 88 Status Detach() override;89 90 Status Signal(int signo) override;91 92 Status Interrupt() override;93 94 Status Kill() override;95 96 Status GetMemoryRegionInfo(lldb::addr_t load_addr,97 MemoryRegionInfo &range_info) override;98 99 Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,100 size_t &bytes_read) override;101 102 Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,103 size_t &bytes_written) override;104 105 llvm::Expected<lldb::addr_t> AllocateMemory(size_t size,106 uint32_t permissions) override;107 108 llvm::Error DeallocateMemory(lldb::addr_t addr) override;109 110 Status ReadMemoryTags(int32_t type, lldb::addr_t addr, size_t len,111 std::vector<uint8_t> &tags) override;112 113 Status WriteMemoryTags(int32_t type, lldb::addr_t addr, size_t len,114 const std::vector<uint8_t> &tags) override;115 116 size_t UpdateThreads() override;117 118 const ArchSpec &GetArchitecture() const override { return m_arch; }119 120 Status SetBreakpoint(lldb::addr_t addr, uint32_t size,121 bool hardware) override;122 123 Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;124 125 void DoStopIDBumped(uint32_t newBumpId) override;126 127 Status GetLoadedModuleFileSpec(const char *module_path,128 FileSpec &file_spec) override;129 130 Status GetFileLoadAddress(const llvm::StringRef &file_name,131 lldb::addr_t &load_addr) override;132 133 NativeThreadLinux *GetThreadByID(lldb::tid_t id);134 NativeThreadLinux *GetCurrentThread();135 136 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>137 GetAuxvData() const override {138 return getProcFile(GetID(), "auxv");139 }140 141 /// Tracing142 /// These methods implement the jLLDBTrace packets143 /// \{144 llvm::Error TraceStart(llvm::StringRef json_request,145 llvm::StringRef type) override;146 147 llvm::Error TraceStop(const TraceStopRequest &request) override;148 149 llvm::Expected<llvm::json::Value>150 TraceGetState(llvm::StringRef type) override;151 152 llvm::Expected<std::vector<uint8_t>>153 TraceGetBinaryData(const TraceGetBinaryDataRequest &request) override;154 155 llvm::Expected<TraceSupportedResponse> TraceSupported() override;156 /// }157 158 // Interface used by NativeRegisterContext-derived classes.159 static Status PtraceWrapper(int req, lldb::pid_t pid, void *addr = nullptr,160 void *data = nullptr, size_t data_size = 0,161 long *result = nullptr);162 163 bool SupportHardwareSingleStepping() const;164 165 /// Writes a siginfo_t structure corresponding to the given thread ID to the166 /// memory region pointed to by \p siginfo.167 Status GetSignalInfo(lldb::tid_t tid, void *siginfo) const;168 169protected:170 llvm::Expected<llvm::ArrayRef<uint8_t>>171 GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;172 173 llvm::Expected<uint64_t> Syscall(llvm::ArrayRef<uint64_t> args);174 175private:176 Manager &m_manager;177 ArchSpec m_arch;178 179 LazyBool m_supports_mem_region = eLazyBoolCalculate;180 std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;181 182 lldb::tid_t m_pending_notification_tid = LLDB_INVALID_THREAD_ID;183 184 /// Inferior memory (allocated by us) and its size.185 llvm::DenseMap<lldb::addr_t, lldb::addr_t> m_allocated_memory;186 187 // Private Instance Methods188 NativeProcessLinux(::pid_t pid, int terminal_fd, NativeDelegate &delegate,189 const ArchSpec &arch, Manager &manager,190 llvm::ArrayRef<::pid_t> tids);191 192 // Returns a list of process threads that we have attached to.193 static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);194 195 static Status SetDefaultPtraceOpts(const lldb::pid_t);196 197 bool TryHandleWaitStatus(lldb::pid_t pid, WaitStatus status);198 199 void MonitorCallback(NativeThreadLinux &thread, WaitStatus status);200 201 void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread);202 203 void MonitorTrace(NativeThreadLinux &thread);204 205 void MonitorBreakpoint(NativeThreadLinux &thread);206 207 void MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index);208 209 void MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread);210 211 bool HasThreadNoLock(lldb::tid_t thread_id);212 213 void StopTrackingThread(NativeThreadLinux &thread);214 215 /// Create a new thread.216 ///217 /// If process tracing is enabled and the thread can't be traced, then the218 /// thread is left stopped with a \a eStopReasonProcessorTrace status, and219 /// then the process is stopped.220 ///221 /// \param[in] resume222 /// If a tracing error didn't happen, then resume the thread after223 /// creation if \b true, or leave it stopped with SIGSTOP if \b false.224 NativeThreadLinux &AddThread(lldb::tid_t thread_id, bool resume);225 226 /// Start tracing a new thread if process tracing is enabled.227 ///228 /// Trace mechanisms should modify this method to provide automatic tracing229 /// for new threads.230 Status NotifyTracersOfNewThread(lldb::tid_t tid);231 232 /// Stop tracing threads upon a destroy event.233 ///234 /// Trace mechanisms should modify this method to provide automatic trace235 /// stopping for threads being destroyed.236 Status NotifyTracersOfThreadDestroyed(lldb::tid_t tid);237 238 void NotifyTracersProcessWillResume() override;239 240 void NotifyTracersProcessDidStop() override;241 242 /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)243 /// corresponding to the given thread ID to the memory pointed to by @p244 /// message.245 Status GetEventMessage(lldb::tid_t tid, unsigned long *message);246 247 void NotifyThreadDeath(lldb::tid_t tid);248 249 Status Detach(lldb::tid_t tid);250 251 // This method is requests a stop on all threads which are still running. It252 // sets up a253 // deferred delegate notification, which will fire once threads report as254 // stopped. The255 // triggerring_tid will be set as the current thread (main stop reason).256 void StopRunningThreads(lldb::tid_t triggering_tid);257 258 // Notify the delegate if all threads have stopped.259 void SignalIfAllThreadsStopped();260 261 // Resume the given thread, optionally passing it the given signal. The type262 // of resume263 // operation (continue, single-step) depends on the state parameter.264 Status ResumeThread(NativeThreadLinux &thread, lldb::StateType state,265 int signo);266 267 void ThreadWasCreated(NativeThreadLinux &thread);268 269 void SigchldHandler();270 271 Status PopulateMemoryRegionCache();272 273 /// Manages Intel PT process and thread traces.274 IntelPTCollector m_intel_pt_collector;275 276 // Handle a clone()-like event.277 bool MonitorClone(NativeThreadLinux &parent, lldb::pid_t child_pid,278 int event);279};280 281} // namespace process_linux282} // namespace lldb_private283 284#endif // #ifndef liblldb_NativeProcessLinux_H_285