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