| //===-- MachProcess.h -------------------------------------------*- C++ -*-===// | |
| // | |
| // The LLVM Compiler Infrastructure | |
| // | |
| // This file is distributed under the University of Illinois Open Source | |
| // License. See LICENSE.TXT for details. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // Created by Greg Clayton on 6/15/07. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef __MachProcess_h__ | |
| #define __MachProcess_h__ | |
| #include "DNBDefs.h" | |
| #include "DNBBreakpoint.h" | |
| #include "DNBError.h" | |
| #include "DNBThreadResumeActions.h" | |
| #include "MachException.h" | |
| #include "MachVMMemory.h" | |
| #include "MachTask.h" | |
| #include "MachThreadList.h" | |
| #include "PThreadCondition.h" | |
| #include "PThreadEvent.h" | |
| #include "PThreadMutex.h" | |
| #include "Genealogy.h" | |
| #include "ThreadInfo.h" | |
| #include "JSONGenerator.h" | |
| #include <mach/mach.h> | |
| #include <sys/signal.h> | |
| #include <pthread.h> | |
| #include <vector> | |
| class DNBThreadResumeActions; | |
| class MachProcess | |
| { | |
| public: | |
| //---------------------------------------------------------------------- | |
| // Constructors and Destructors | |
| //---------------------------------------------------------------------- | |
| MachProcess (); | |
| ~MachProcess (); | |
| //---------------------------------------------------------------------- | |
| // Child process control | |
| //---------------------------------------------------------------------- | |
| pid_t AttachForDebug (pid_t pid, char *err_str, size_t err_len); | |
| pid_t LaunchForDebug (const char *path, | |
| char const *argv[], | |
| char const *envp[], | |
| const char *working_directory, | |
| const char *stdin_path, | |
| const char *stdout_path, | |
| const char *stderr_path, | |
| bool no_stdio, | |
| nub_launch_flavor_t launch_flavor, | |
| int disable_aslr, | |
| const char *event_data, | |
| DNBError &err); | |
| static uint32_t GetCPUTypeForLocalProcess (pid_t pid); | |
| static pid_t ForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], MachProcess* process, DNBError &err); | |
| static pid_t PosixSpawnChildForPTraceDebugging (const char *path, | |
| cpu_type_t cpu_type, | |
| char const *argv[], | |
| char const *envp[], | |
| const char *working_directory, | |
| const char *stdin_path, | |
| const char *stdout_path, | |
| const char *stderr_path, | |
| bool no_stdio, | |
| MachProcess* process, | |
| int disable_aslr, | |
| DNBError& err); | |
| nub_addr_t GetDYLDAllImageInfosAddress (); | |
| static const void * PrepareForAttach (const char *path, nub_launch_flavor_t launch_flavor, bool waitfor, DNBError &err_str); | |
| static void CleanupAfterAttach (const void *attach_token, bool success, DNBError &err_str); | |
| static nub_process_t CheckForProcess (const void *attach_token); | |
| #ifdef WITH_BKS | |
| pid_t BKSLaunchForDebug (const char *app_bundle_path, char const *argv[], char const *envp[], bool no_stdio, bool disable_aslr, const char *event_data, DNBError &launch_err); | |
| pid_t BKSForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], bool no_stdio, bool disable_aslr, const char *event_data, DNBError &launch_err); | |
| bool BKSSendEvent (const char *event, DNBError &error); | |
| static void BKSCleanupAfterAttach (const void *attach_token, DNBError &err_str); | |
| #endif | |
| #ifdef WITH_SPRINGBOARD | |
| pid_t SBLaunchForDebug (const char *app_bundle_path, char const *argv[], char const *envp[], bool no_stdio, bool disable_aslr, DNBError &launch_err); | |
| static pid_t SBForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], bool no_stdio, MachProcess* process, DNBError &launch_err); | |
| #endif | |
| nub_addr_t LookupSymbol (const char *name, const char *shlib); | |
| void SetNameToAddressCallback (DNBCallbackNameToAddress callback, void *baton) | |
| { | |
| m_name_to_addr_callback = callback; | |
| m_name_to_addr_baton = baton; | |
| } | |
| void SetSharedLibraryInfoCallback (DNBCallbackCopyExecutableImageInfos callback, void *baton) | |
| { | |
| m_image_infos_callback = callback; | |
| m_image_infos_baton = baton; | |
| } | |
| bool Resume (const DNBThreadResumeActions& thread_actions); | |
| bool Signal (int signal, const struct timespec *timeout_abstime = NULL); | |
| bool Interrupt(); | |
| bool SendEvent (const char *event, DNBError &send_err); | |
| bool Kill (const struct timespec *timeout_abstime = NULL); | |
| bool Detach (); | |
| nub_size_t ReadMemory (nub_addr_t addr, nub_size_t size, void *buf); | |
| nub_size_t WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf); | |
| //---------------------------------------------------------------------- | |
| // Path and arg accessors | |
| //---------------------------------------------------------------------- | |
| const char * Path () const { return m_path.c_str(); } | |
| size_t ArgumentCount () const { return m_args.size(); } | |
| const char * ArgumentAtIndex (size_t arg_idx) const | |
| { | |
| if (arg_idx < m_args.size()) | |
| return m_args[arg_idx].c_str(); | |
| return NULL; | |
| } | |
| //---------------------------------------------------------------------- | |
| // Breakpoint functions | |
| //---------------------------------------------------------------------- | |
| DNBBreakpoint * CreateBreakpoint (nub_addr_t addr, nub_size_t length, bool hardware); | |
| bool DisableBreakpoint (nub_addr_t addr, bool remove); | |
| void DisableAllBreakpoints (bool remove); | |
| bool EnableBreakpoint (nub_addr_t addr); | |
| DNBBreakpointList& Breakpoints() { return m_breakpoints; } | |
| const DNBBreakpointList& Breakpoints() const { return m_breakpoints; } | |
| //---------------------------------------------------------------------- | |
| // Watchpoint functions | |
| //---------------------------------------------------------------------- | |
| DNBBreakpoint * CreateWatchpoint (nub_addr_t addr, nub_size_t length, uint32_t watch_type, bool hardware); | |
| bool DisableWatchpoint (nub_addr_t addr, bool remove); | |
| void DisableAllWatchpoints (bool remove); | |
| bool EnableWatchpoint (nub_addr_t addr); | |
| uint32_t GetNumSupportedHardwareWatchpoints () const; | |
| DNBBreakpointList& Watchpoints() { return m_watchpoints; } | |
| const DNBBreakpointList& Watchpoints() const { return m_watchpoints; } | |
| //---------------------------------------------------------------------- | |
| // Exception thread functions | |
| //---------------------------------------------------------------------- | |
| bool StartSTDIOThread (); | |
| static void * STDIOThread (void *arg); | |
| void ExceptionMessageReceived (const MachException::Message& exceptionMessage); | |
| task_t ExceptionMessageBundleComplete (); | |
| void SharedLibrariesUpdated (); | |
| nub_size_t CopyImageInfos (struct DNBExecutableImageInfo **image_infos, bool only_changed); | |
| //---------------------------------------------------------------------- | |
| // Profile functions | |
| //---------------------------------------------------------------------- | |
| void SetEnableAsyncProfiling (bool enable, uint64_t internal_usec, DNBProfileDataScanType scan_type); | |
| bool IsProfilingEnabled () { return m_profile_enabled; } | |
| useconds_t ProfileInterval () { return m_profile_interval_usec; } | |
| bool StartProfileThread (); | |
| static void * ProfileThread (void *arg); | |
| void SignalAsyncProfileData (const char *info); | |
| size_t GetAsyncProfileData (char *buf, size_t buf_size); | |
| //---------------------------------------------------------------------- | |
| // Accessors | |
| //---------------------------------------------------------------------- | |
| pid_t ProcessID () const { return m_pid; } | |
| bool ProcessIDIsValid () const { return m_pid > 0; } | |
| pid_t SetProcessID (pid_t pid); | |
| MachTask& Task() { return m_task; } | |
| const MachTask& Task() const { return m_task; } | |
| PThreadEvent& Events() { return m_events; } | |
| const DNBRegisterSetInfo * | |
| GetRegisterSetInfo (nub_thread_t tid, nub_size_t *num_reg_sets) const; | |
| bool GetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *reg_value) const; | |
| bool SetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value) const; | |
| nub_bool_t SyncThreadState (nub_thread_t tid); | |
| const char * ThreadGetName (nub_thread_t tid); | |
| nub_state_t ThreadGetState (nub_thread_t tid); | |
| ThreadInfo::QoS GetRequestedQoS (nub_thread_t tid, nub_addr_t tsd, uint64_t dti_qos_class_index); | |
| nub_addr_t GetPThreadT (nub_thread_t tid); | |
| nub_addr_t GetDispatchQueueT (nub_thread_t tid); | |
| nub_addr_t GetTSDAddressForThread (nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset, uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size); | |
| JSONGenerator::ObjectSP GetLoadedDynamicLibrariesInfos (nub_process_t pid, nub_addr_t image_list_address, nub_addr_t image_count); | |
| nub_size_t GetNumThreads () const; | |
| nub_thread_t GetThreadAtIndex (nub_size_t thread_idx) const; | |
| nub_thread_t GetCurrentThread (); | |
| nub_thread_t GetCurrentThreadMachPort (); | |
| nub_thread_t SetCurrentThread (nub_thread_t tid); | |
| MachThreadList & GetThreadList() { return m_thread_list; } | |
| bool GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info); | |
| void DumpThreadStoppedReason(nub_thread_t tid) const; | |
| const char * GetThreadInfo (nub_thread_t tid) const; | |
| nub_thread_t GetThreadIDForMachPortNumber (thread_t mach_port_number) const; | |
| uint32_t GetCPUType (); | |
| nub_state_t GetState (); | |
| void SetState (nub_state_t state); | |
| bool IsRunning (nub_state_t state) | |
| { | |
| return state == eStateRunning || IsStepping(state); | |
| } | |
| bool IsStepping (nub_state_t state) | |
| { | |
| return state == eStateStepping; | |
| } | |
| bool CanResume (nub_state_t state) | |
| { | |
| return state == eStateStopped; | |
| } | |
| bool GetExitStatus(int* status) | |
| { | |
| if (GetState() == eStateExited) | |
| { | |
| if (status) | |
| *status = m_exit_status; | |
| return true; | |
| } | |
| return false; | |
| } | |
| void SetExitStatus(int status) | |
| { | |
| m_exit_status = status; | |
| SetState(eStateExited); | |
| } | |
| const char * GetExitInfo () | |
| { | |
| return m_exit_info.c_str(); | |
| } | |
| void SetExitInfo (const char *info); | |
| uint32_t StopCount() const { return m_stop_count; } | |
| void SetChildFileDescriptors (int stdin_fileno, int stdout_fileno, int stderr_fileno) | |
| { | |
| m_child_stdin = stdin_fileno; | |
| m_child_stdout = stdout_fileno; | |
| m_child_stderr = stderr_fileno; | |
| } | |
| int GetStdinFileDescriptor () const { return m_child_stdin; } | |
| int GetStdoutFileDescriptor () const { return m_child_stdout; } | |
| int GetStderrFileDescriptor () const { return m_child_stderr; } | |
| void AppendSTDOUT (char* s, size_t len); | |
| size_t GetAvailableSTDOUT (char *buf, size_t buf_size); | |
| size_t GetAvailableSTDERR (char *buf, size_t buf_size); | |
| void CloseChildFileDescriptors () | |
| { | |
| if (m_child_stdin >= 0) | |
| { | |
| ::close (m_child_stdin); | |
| m_child_stdin = -1; | |
| } | |
| if (m_child_stdout >= 0) | |
| { | |
| ::close (m_child_stdout); | |
| m_child_stdout = -1; | |
| } | |
| if (m_child_stderr >= 0) | |
| { | |
| ::close (m_child_stderr); | |
| m_child_stderr = -1; | |
| } | |
| } | |
| bool ProcessUsingSpringBoard() const { return (m_flags & eMachProcessFlagsUsingSBS) != 0; } | |
| bool ProcessUsingBackBoard() const { return (m_flags & eMachProcessFlagsUsingBKS) != 0; } | |
| Genealogy::ThreadActivitySP GetGenealogyInfoForThread (nub_thread_t tid, bool &timed_out); | |
| Genealogy::ProcessExecutableInfoSP GetGenealogyImageInfo (size_t idx); | |
| DNBProfileDataScanType GetProfileScanType () { return m_profile_scan_type; } | |
| private: | |
| enum | |
| { | |
| eMachProcessFlagsNone = 0, | |
| eMachProcessFlagsAttached = (1 << 0), | |
| eMachProcessFlagsUsingSBS = (1 << 1), | |
| eMachProcessFlagsUsingBKS = (1 << 2) | |
| }; | |
| void Clear (bool detaching = false); | |
| void ReplyToAllExceptions (); | |
| void PrivateResume (); | |
| uint32_t Flags () const { return m_flags; } | |
| nub_state_t DoSIGSTOP (bool clear_bps_and_wps, bool allow_running, uint32_t *thread_idx_ptr); | |
| pid_t m_pid; // Process ID of child process | |
| cpu_type_t m_cpu_type; // The CPU type of this process | |
| int m_child_stdin; | |
| int m_child_stdout; | |
| int m_child_stderr; | |
| std::string m_path; // A path to the executable if we have one | |
| std::vector<std::string> m_args; // The arguments with which the process was lauched | |
| int m_exit_status; // The exit status for the process | |
| std::string m_exit_info; // Any extra info that we may have about the exit | |
| MachTask m_task; // The mach task for this process | |
| uint32_t m_flags; // Process specific flags (see eMachProcessFlags enums) | |
| uint32_t m_stop_count; // A count of many times have we stopped | |
| pthread_t m_stdio_thread; // Thread ID for the thread that watches for child process stdio | |
| PThreadMutex m_stdio_mutex; // Multithreaded protection for stdio | |
| std::string m_stdout_data; | |
| bool m_profile_enabled; // A flag to indicate if profiling is enabled | |
| useconds_t m_profile_interval_usec; // If enable, the profiling interval in microseconds | |
| DNBProfileDataScanType m_profile_scan_type; // Indicates what needs to be profiled | |
| pthread_t m_profile_thread; // Thread ID for the thread that profiles the inferior | |
| PThreadMutex m_profile_data_mutex; // Multithreaded protection for profile info data | |
| std::vector<std::string> m_profile_data; // Profile data, must be protected by m_profile_data_mutex | |
| DNBThreadResumeActions m_thread_actions; // The thread actions for the current MachProcess::Resume() call | |
| MachException::Message::collection | |
| m_exception_messages; // A collection of exception messages caught when listening to the exception port | |
| PThreadMutex m_exception_messages_mutex; // Multithreaded protection for m_exception_messages | |
| MachThreadList m_thread_list; // A list of threads that is maintained/updated after each stop | |
| Genealogy m_activities; // A list of activities that is updated after every stop lazily | |
| nub_state_t m_state; // The state of our process | |
| PThreadMutex m_state_mutex; // Multithreaded protection for m_state | |
| PThreadEvent m_events; // Process related events in the child processes lifetime can be waited upon | |
| PThreadEvent m_private_events; // Used to coordinate running and stopping the process without affecting m_events | |
| DNBBreakpointList m_breakpoints; // Breakpoint list for this process | |
| DNBBreakpointList m_watchpoints; // Watchpoint list for this process | |
| DNBCallbackNameToAddress m_name_to_addr_callback; | |
| void * m_name_to_addr_baton; | |
| DNBCallbackCopyExecutableImageInfos | |
| m_image_infos_callback; | |
| void * m_image_infos_baton; | |
| std::string m_bundle_id; // If we are a SB or BKS process, this will be our bundle ID. | |
| int m_sent_interrupt_signo; // When we call MachProcess::Interrupt(), we want to send a single signal | |
| // to the inferior and only send the signal if we aren't already stopped. | |
| // If we end up sending a signal to stop the process we store it until we | |
| // receive an exception with this signal. This helps us to verify we got | |
| // the signal that interrupted the process. We might stop due to another | |
| // reason after an interrupt signal is sent, so this helps us ensure that | |
| // we don't report a spurious stop on the next resume. | |
| int m_auto_resume_signo; // If we resume the process and still haven't received our interrupt signal | |
| // acknownledgement, we will shortly after the next resume. We store the | |
| // interrupt signal in this variable so when we get the interrupt signal | |
| // as the sole reason for the process being stopped, we can auto resume | |
| // the process. | |
| bool m_did_exec; | |
| }; | |
| #endif // __MachProcess_h__ |