Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- MachProcess.h -------------------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // Created by Greg Clayton on 6/15/07. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #ifndef __MachProcess_h__ |
| 15 | #define __MachProcess_h__ |
| 16 | |
| 17 | #include "DNBDefs.h" |
| 18 | #include "DNBBreakpoint.h" |
| 19 | #include "DNBError.h" |
| 20 | //#include "MachDYLD.h" |
| 21 | #include "MachException.h" |
| 22 | #include "MachVMMemory.h" |
| 23 | #include "MachTask.h" |
| 24 | #include "MachThreadList.h" |
| 25 | #include "PThreadCondition.h" |
| 26 | #include "PThreadEvent.h" |
| 27 | #include "PThreadMutex.h" |
| 28 | |
| 29 | #include <mach/mach.h> |
| 30 | #include <sys/signal.h> |
| 31 | #include <pthread.h> |
| 32 | #include <vector> |
| 33 | |
| 34 | class DNBThreadResumeActions; |
| 35 | |
| 36 | class MachProcess |
| 37 | { |
| 38 | public: |
| 39 | //---------------------------------------------------------------------- |
| 40 | // Constructors and Destructors |
| 41 | //---------------------------------------------------------------------- |
| 42 | MachProcess (); |
| 43 | ~MachProcess (); |
| 44 | |
| 45 | //---------------------------------------------------------------------- |
| 46 | // Child process control |
| 47 | //---------------------------------------------------------------------- |
| 48 | pid_t AttachForDebug (pid_t pid, char *err_str, size_t err_len); |
Greg Clayton | 452bf61 | 2010-08-31 18:35:14 +0000 | [diff] [blame] | 49 | pid_t LaunchForDebug (const char *path, char const *argv[], char const *envp[], const char *stdio_path, nub_launch_flavor_t launch_flavor, int disable_aslr, DNBError &err); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 50 | static pid_t ForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], MachProcess* process, DNBError &err); |
Greg Clayton | 20d338f | 2010-11-18 05:57:03 +0000 | [diff] [blame^] | 51 | static pid_t PosixSpawnChildForPTraceDebugging (const char *path, cpu_type_t cpu_type, char const *argv[], char const *envp[], const char *stdio_path, MachProcess* process, int disable_aslr, DNBError& err); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 52 | nub_addr_t GetDYLDAllImageInfosAddress (); |
| 53 | static const void * PrepareForAttach (const char *path, nub_launch_flavor_t launch_flavor, bool waitfor, DNBError &err_str); |
| 54 | static void CleanupAfterAttach (const void *attach_token, bool success, DNBError &err_str); |
| 55 | static nub_process_t CheckForProcess (const void *attach_token); |
| 56 | #if defined (__arm__) |
| 57 | pid_t SBLaunchForDebug (const char *app_bundle_path, char const *argv[], char const *envp[], DNBError &launch_err); |
| 58 | static pid_t SBForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], MachProcess* process, DNBError &launch_err); |
| 59 | #endif |
| 60 | nub_addr_t LookupSymbol (const char *name, const char *shlib); |
| 61 | void SetNameToAddressCallback (DNBCallbackNameToAddress callback, void *baton) |
| 62 | { |
| 63 | m_name_to_addr_callback = callback; |
| 64 | m_name_to_addr_baton = baton; |
| 65 | } |
| 66 | void SetSharedLibraryInfoCallback (DNBCallbackCopyExecutableImageInfos callback, void *baton) |
| 67 | { |
| 68 | m_image_infos_callback = callback; |
| 69 | m_image_infos_baton = baton; |
| 70 | } |
| 71 | |
| 72 | bool Resume (const DNBThreadResumeActions& thread_actions); |
| 73 | bool Signal (int signal, const struct timespec *timeout_abstime = NULL); |
| 74 | bool Kill (const struct timespec *timeout_abstime = NULL); |
| 75 | bool Detach (); |
| 76 | nub_size_t ReadMemory (nub_addr_t addr, nub_size_t size, void *buf); |
| 77 | nub_size_t WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf); |
| 78 | |
| 79 | //---------------------------------------------------------------------- |
| 80 | // Path and arg accessors |
| 81 | //---------------------------------------------------------------------- |
| 82 | const char * Path () const { return m_path.c_str(); } |
| 83 | size_t ArgumentCount () const { return m_args.size(); } |
| 84 | const char * ArgumentAtIndex (size_t arg_idx) const |
| 85 | { |
| 86 | if (arg_idx < m_args.size()) |
| 87 | return m_args[arg_idx].c_str(); |
| 88 | return NULL; |
| 89 | } |
| 90 | |
| 91 | //---------------------------------------------------------------------- |
| 92 | // Breakpoint functions |
| 93 | //---------------------------------------------------------------------- |
| 94 | nub_break_t CreateBreakpoint (nub_addr_t addr, nub_size_t length, bool hardware, thread_t thread); |
| 95 | bool DisableBreakpoint (nub_break_t breakID, bool remove); |
| 96 | nub_size_t DisableAllBreakpoints (bool remove); |
| 97 | bool EnableBreakpoint (nub_break_t breakID); |
| 98 | void DumpBreakpoint(nub_break_t breakID) const; |
| 99 | DNBBreakpointList& Breakpoints() { return m_breakpoints; } |
| 100 | const DNBBreakpointList& Breakpoints() const { return m_breakpoints; } |
| 101 | |
| 102 | //---------------------------------------------------------------------- |
| 103 | // Watchpoint functions |
| 104 | //---------------------------------------------------------------------- |
| 105 | nub_watch_t CreateWatchpoint (nub_addr_t addr, nub_size_t length, uint32_t watch_type, bool hardware, thread_t thread); |
| 106 | bool DisableWatchpoint (nub_watch_t watchID, bool remove); |
| 107 | nub_size_t DisableAllWatchpoints (bool remove); |
| 108 | bool EnableWatchpoint (nub_watch_t watchID); |
| 109 | void DumpWatchpoint(nub_watch_t watchID) const; |
| 110 | DNBBreakpointList& Watchpoints() { return m_watchpoints; } |
| 111 | const DNBBreakpointList& Watchpoints() const { return m_watchpoints; } |
| 112 | |
| 113 | //---------------------------------------------------------------------- |
| 114 | // Exception thread functions |
| 115 | //---------------------------------------------------------------------- |
| 116 | bool StartSTDIOThread (); |
| 117 | static void * STDIOThread (void *arg); |
| 118 | void ExceptionMessageReceived (const MachException::Message& exceptionMessage); |
| 119 | void ExceptionMessageBundleComplete (); |
| 120 | void SharedLibrariesUpdated (); |
| 121 | nub_size_t CopyImageInfos (struct DNBExecutableImageInfo **image_infos, bool only_changed); |
| 122 | |
| 123 | //---------------------------------------------------------------------- |
| 124 | // Accessors |
| 125 | //---------------------------------------------------------------------- |
| 126 | pid_t ProcessID () const { return m_pid; } |
| 127 | bool ProcessIDIsValid () const { return m_pid > 0; } |
| 128 | pid_t SetProcessID (pid_t pid); |
| 129 | MachTask& Task() { return m_task; } |
| 130 | const MachTask& Task() const { return m_task; } |
| 131 | |
| 132 | PThreadEvent& Events() { return m_events; } |
| 133 | const DNBRegisterSetInfo * |
| 134 | GetRegisterSetInfo (nub_thread_t tid, nub_size_t *num_reg_sets) const; |
| 135 | bool GetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *reg_value) const; |
| 136 | bool SetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value) const; |
| 137 | const char * ThreadGetName (nub_thread_t tid); |
| 138 | nub_state_t ThreadGetState (nub_thread_t tid); |
| 139 | nub_size_t GetNumThreads () const; |
| 140 | nub_thread_t GetThreadAtIndex (nub_size_t thread_idx) const; |
| 141 | uint32_t GetThreadIndexFromThreadID (nub_thread_t tid); |
| 142 | nub_thread_t GetCurrentThread (); |
| 143 | nub_thread_t SetCurrentThread (nub_thread_t tid); |
Greg Clayton | 3b2c41c | 2010-10-18 04:14:23 +0000 | [diff] [blame] | 144 | MachThreadList & GetThreadList() { return m_thread_list; } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 145 | bool GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info) const; |
| 146 | void DumpThreadStoppedReason(nub_thread_t tid) const; |
| 147 | const char * GetThreadInfo (nub_thread_t tid) const; |
| 148 | |
| 149 | nub_state_t GetState (); |
| 150 | void SetState (nub_state_t state); |
| 151 | bool IsRunning (nub_state_t state) |
| 152 | { |
| 153 | return state == eStateRunning || IsStepping(state); |
| 154 | } |
| 155 | bool IsStepping (nub_state_t state) |
| 156 | { |
| 157 | return state == eStateStepping; |
| 158 | } |
| 159 | bool CanResume (nub_state_t state) |
| 160 | { |
| 161 | return state == eStateStopped; |
| 162 | } |
| 163 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 164 | bool GetExitStatus(int* status) |
| 165 | { |
| 166 | if (GetState() == eStateExited) |
| 167 | { |
| 168 | if (status) |
| 169 | *status = m_exit_status; |
| 170 | return true; |
| 171 | } |
| 172 | return false; |
| 173 | } |
| 174 | void SetExitStatus(int status) |
| 175 | { |
| 176 | m_exit_status = status; |
| 177 | SetState(eStateExited); |
| 178 | } |
| 179 | |
| 180 | uint32_t StopCount() const { return m_stop_count; } |
| 181 | void SetChildFileDescriptors (int stdin_fileno, int stdout_fileno, int stderr_fileno) |
| 182 | { |
| 183 | m_child_stdin = stdin_fileno; |
| 184 | m_child_stdout = stdout_fileno; |
| 185 | m_child_stderr = stderr_fileno; |
| 186 | } |
| 187 | |
| 188 | int GetStdinFileDescriptor () const { return m_child_stdin; } |
| 189 | int GetStdoutFileDescriptor () const { return m_child_stdout; } |
| 190 | int GetStderrFileDescriptor () const { return m_child_stderr; } |
| 191 | void AppendSTDOUT (char* s, size_t len); |
| 192 | size_t GetAvailableSTDOUT (char *buf, size_t buf_size); |
| 193 | size_t GetAvailableSTDERR (char *buf, size_t buf_size); |
| 194 | void CloseChildFileDescriptors () |
| 195 | { |
| 196 | if (m_child_stdin >= 0) |
| 197 | { |
| 198 | ::close (m_child_stdin); |
| 199 | m_child_stdin = -1; |
| 200 | } |
| 201 | if (m_child_stdout >= 0) |
| 202 | { |
| 203 | ::close (m_child_stdout); |
| 204 | m_child_stdout = -1; |
| 205 | } |
| 206 | if (m_child_stderr >= 0) |
| 207 | { |
| 208 | ::close (m_child_stderr); |
| 209 | m_child_stderr = -1; |
| 210 | } |
| 211 | } |
| 212 | |
| 213 | bool ProcessUsingSpringBoard() const { return (m_flags & eMachProcessFlagsUsingSBS) != 0; } |
| 214 | private: |
| 215 | enum |
| 216 | { |
| 217 | eMachProcessFlagsNone = 0, |
| 218 | eMachProcessFlagsAttached = (1 << 0), |
| 219 | eMachProcessFlagsUsingSBS = (1 << 1) |
| 220 | }; |
| 221 | void Clear (); |
| 222 | void ReplyToAllExceptions (const DNBThreadResumeActions& thread_actions); |
| 223 | void PrivateResume (const DNBThreadResumeActions& thread_actions); |
| 224 | nub_size_t RemoveTrapsFromBuffer (nub_addr_t addr, nub_size_t size, uint8_t *buf) const; |
| 225 | |
| 226 | uint32_t Flags () const { return m_flags; } |
Caroline Tice | 90b4225 | 2010-11-02 16:16:53 +0000 | [diff] [blame] | 227 | nub_state_t DoSIGSTOP (bool clear_bps_and_wps, uint32_t *thread_idx_ptr = NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 228 | |
| 229 | pid_t m_pid; // Process ID of child process |
| 230 | int m_child_stdin; |
| 231 | int m_child_stdout; |
| 232 | int m_child_stderr; |
| 233 | std::string m_path; // A path to the executable if we have one |
| 234 | std::vector<std::string> m_args; // The arguments with which the process was lauched |
| 235 | int m_exit_status; // The exit status for the process |
| 236 | MachTask m_task; // The mach task for this process |
| 237 | uint32_t m_flags; // Process specific flags (see eMachProcessFlags enums) |
| 238 | uint32_t m_stop_count; // A count of many times have we stopped |
| 239 | pthread_t m_stdio_thread; // Thread ID for the thread that watches for child process stdio |
| 240 | PThreadMutex m_stdio_mutex; // Multithreaded protection for stdio |
| 241 | std::string m_stdout_data; |
| 242 | MachException::Message::collection |
| 243 | m_exception_messages; // A collection of exception messages caught when listening to the exception port |
| 244 | PThreadMutex m_exception_messages_mutex; // Multithreaded protection for m_exception_messages |
| 245 | |
Greg Clayton | 3b2c41c | 2010-10-18 04:14:23 +0000 | [diff] [blame] | 246 | MachThreadList m_thread_list; // A list of threads that is maintained/updated after each stop |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 247 | nub_state_t m_state; // The state of our process |
| 248 | PThreadMutex m_state_mutex; // Multithreaded protection for m_state |
| 249 | PThreadEvent m_events; // Process related events in the child processes lifetime can be waited upon |
| 250 | DNBBreakpointList m_breakpoints; // Breakpoint list for this process |
| 251 | DNBBreakpointList m_watchpoints; // Watchpoint list for this process |
| 252 | DNBCallbackNameToAddress m_name_to_addr_callback; |
| 253 | void * m_name_to_addr_baton; |
| 254 | DNBCallbackCopyExecutableImageInfos |
| 255 | m_image_infos_callback; |
| 256 | void * m_image_infos_baton; |
Greg Clayton | 20d338f | 2010-11-18 05:57:03 +0000 | [diff] [blame^] | 257 | DNBArchPluginInfo m_arch_plugin_info; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 258 | }; |
| 259 | |
| 260 | |
| 261 | #endif // __MachProcess_h__ |