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 "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); 49 pid_t LaunchForDebug (const char *path, 50 char const *argv[], 51 char const *envp[], 52 const char *working_directory, 53 const char *stdin_path, 54 const char *stdout_path, 55 const char *stderr_path, 56 bool no_stdio, 57 nub_launch_flavor_t launch_flavor, 58 int disable_aslr, 59 const char *event_data, 60 DNBError &err); 61 62 static uint32_t GetCPUTypeForLocalProcess (pid_t pid); 63 static pid_t ForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], MachProcess* process, DNBError &err); 64 static pid_t PosixSpawnChildForPTraceDebugging (const char *path, 65 cpu_type_t cpu_type, 66 char const *argv[], 67 char const *envp[], 68 const char *working_directory, 69 const char *stdin_path, 70 const char *stdout_path, 71 const char *stderr_path, 72 bool no_stdio, 73 MachProcess* process, 74 int disable_aslr, 75 DNBError& err); 76 nub_addr_t GetDYLDAllImageInfosAddress (); 77 static const void * PrepareForAttach (const char *path, nub_launch_flavor_t launch_flavor, bool waitfor, DNBError &err_str); 78 static void CleanupAfterAttach (const void *attach_token, bool success, DNBError &err_str); 79 static nub_process_t CheckForProcess (const void *attach_token); 80 #ifdef WITH_BKS 81 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); 82 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); 83 bool BKSSendEvent (const char *event, DNBError &error); 84 static void BKSCleanupAfterAttach (const void *attach_token, DNBError &err_str); 85 #endif 86 #ifdef WITH_SPRINGBOARD 87 pid_t SBLaunchForDebug (const char *app_bundle_path, char const *argv[], char const *envp[], bool no_stdio, bool disable_aslr, DNBError &launch_err); 88 static pid_t SBForkChildForPTraceDebugging (const char *path, char const *argv[], char const *envp[], bool no_stdio, MachProcess* process, DNBError &launch_err); 89 #endif 90 nub_addr_t LookupSymbol (const char *name, const char *shlib); 91 void SetNameToAddressCallback (DNBCallbackNameToAddress callback, void *baton) 92 { 93 m_name_to_addr_callback = callback; 94 m_name_to_addr_baton = baton; 95 } 96 void SetSharedLibraryInfoCallback (DNBCallbackCopyExecutableImageInfos callback, void *baton) 97 { 98 m_image_infos_callback = callback; 99 m_image_infos_baton = baton; 100 } 101 102 bool Resume (const DNBThreadResumeActions& thread_actions); 103 bool Signal (int signal, const struct timespec *timeout_abstime = NULL); 104 bool SendEvent (const char *event, DNBError &send_err); 105 bool Kill (const struct timespec *timeout_abstime = NULL); 106 bool Detach (); 107 nub_size_t ReadMemory (nub_addr_t addr, nub_size_t size, void *buf); 108 nub_size_t WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf); 109 110 //---------------------------------------------------------------------- 111 // Path and arg accessors 112 //---------------------------------------------------------------------- 113 const char * Path () const { return m_path.c_str(); } 114 size_t ArgumentCount () const { return m_args.size(); } 115 const char * ArgumentAtIndex (size_t arg_idx) const 116 { 117 if (arg_idx < m_args.size()) 118 return m_args[arg_idx].c_str(); 119 return NULL; 120 } 121 122 //---------------------------------------------------------------------- 123 // Breakpoint functions 124 //---------------------------------------------------------------------- 125 DNBBreakpoint * CreateBreakpoint (nub_addr_t addr, nub_size_t length, bool hardware); 126 bool DisableBreakpoint (nub_addr_t addr, bool remove); 127 void DisableAllBreakpoints (bool remove); 128 bool EnableBreakpoint (nub_addr_t addr); 129 DNBBreakpointList& Breakpoints() { return m_breakpoints; } 130 const DNBBreakpointList& Breakpoints() const { return m_breakpoints; } 131 132 //---------------------------------------------------------------------- 133 // Watchpoint functions 134 //---------------------------------------------------------------------- 135 DNBBreakpoint * CreateWatchpoint (nub_addr_t addr, nub_size_t length, uint32_t watch_type, bool hardware); 136 bool DisableWatchpoint (nub_addr_t addr, bool remove); 137 void DisableAllWatchpoints (bool remove); 138 bool EnableWatchpoint (nub_addr_t addr); 139 uint32_t GetNumSupportedHardwareWatchpoints () const; 140 DNBBreakpointList& Watchpoints() { return m_watchpoints; } 141 const DNBBreakpointList& Watchpoints() const { return m_watchpoints; } 142 143 //---------------------------------------------------------------------- 144 // Exception thread functions 145 //---------------------------------------------------------------------- 146 bool StartSTDIOThread (); 147 static void * STDIOThread (void *arg); 148 void ExceptionMessageReceived (const MachException::Message& exceptionMessage); 149 void ExceptionMessageBundleComplete (); 150 void SharedLibrariesUpdated (); 151 nub_size_t CopyImageInfos (struct DNBExecutableImageInfo **image_infos, bool only_changed); 152 153 //---------------------------------------------------------------------- 154 // Profile functions 155 //---------------------------------------------------------------------- 156 void SetEnableAsyncProfiling (bool enable, uint64_t internal_usec, DNBProfileDataScanType scan_type); 157 bool IsProfilingEnabled () { return m_profile_enabled; } 158 uint64_t ProfileInterval () { return m_profile_interval_usec; } 159 bool StartProfileThread (); 160 static void * ProfileThread (void *arg); 161 void SignalAsyncProfileData (const char *info); 162 size_t GetAsyncProfileData (char *buf, size_t buf_size); 163 164 //---------------------------------------------------------------------- 165 // Accessors 166 //---------------------------------------------------------------------- 167 pid_t ProcessID () const { return m_pid; } 168 bool ProcessIDIsValid () const { return m_pid > 0; } 169 pid_t SetProcessID (pid_t pid); 170 MachTask& Task() { return m_task; } 171 const MachTask& Task() const { return m_task; } 172 173 PThreadEvent& Events() { return m_events; } 174 const DNBRegisterSetInfo * 175 GetRegisterSetInfo (nub_thread_t tid, nub_size_t *num_reg_sets) const; 176 bool GetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *reg_value) const; 177 bool SetRegisterValue (nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value) const; 178 nub_bool_t SyncThreadState (nub_thread_t tid); 179 const char * ThreadGetName (nub_thread_t tid); 180 nub_state_t ThreadGetState (nub_thread_t tid); 181 nub_size_t GetNumThreads () const; 182 nub_thread_t GetThreadAtIndex (nub_size_t thread_idx) const; 183 nub_thread_t GetCurrentThread (); 184 nub_thread_t GetCurrentThreadMachPort (); 185 nub_thread_t SetCurrentThread (nub_thread_t tid); 186 MachThreadList & GetThreadList() { return m_thread_list; } 187 bool GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info); 188 void DumpThreadStoppedReason(nub_thread_t tid) const; 189 const char * GetThreadInfo (nub_thread_t tid) const; 190 191 nub_thread_t GetThreadIDForMachPortNumber (thread_t mach_port_number) const; 192 193 uint32_t GetCPUType (); 194 nub_state_t GetState (); 195 void SetState (nub_state_t state); 196 bool IsRunning (nub_state_t state) 197 { 198 return state == eStateRunning || IsStepping(state); 199 } 200 bool IsStepping (nub_state_t state) 201 { 202 return state == eStateStepping; 203 } 204 bool CanResume (nub_state_t state) 205 { 206 return state == eStateStopped; 207 } 208 209 bool GetExitStatus(int* status) 210 { 211 if (GetState() == eStateExited) 212 { 213 if (status) 214 *status = m_exit_status; 215 return true; 216 } 217 return false; 218 } 219 void SetExitStatus(int status) 220 { 221 m_exit_status = status; 222 SetState(eStateExited); 223 } 224 const char * GetExitInfo () 225 { 226 return m_exit_info.c_str(); 227 } 228 229 void SetExitInfo (const char *info) 230 { 231 m_exit_info.assign(info); 232 } 233 234 uint32_t StopCount() const { return m_stop_count; } 235 void SetChildFileDescriptors (int stdin_fileno, int stdout_fileno, int stderr_fileno) 236 { 237 m_child_stdin = stdin_fileno; 238 m_child_stdout = stdout_fileno; 239 m_child_stderr = stderr_fileno; 240 } 241 242 int GetStdinFileDescriptor () const { return m_child_stdin; } 243 int GetStdoutFileDescriptor () const { return m_child_stdout; } 244 int GetStderrFileDescriptor () const { return m_child_stderr; } 245 void AppendSTDOUT (char* s, size_t len); 246 size_t GetAvailableSTDOUT (char *buf, size_t buf_size); 247 size_t GetAvailableSTDERR (char *buf, size_t buf_size); 248 void CloseChildFileDescriptors () 249 { 250 if (m_child_stdin >= 0) 251 { 252 ::close (m_child_stdin); 253 m_child_stdin = -1; 254 } 255 if (m_child_stdout >= 0) 256 { 257 ::close (m_child_stdout); 258 m_child_stdout = -1; 259 } 260 if (m_child_stderr >= 0) 261 { 262 ::close (m_child_stderr); 263 m_child_stderr = -1; 264 } 265 } 266 267 bool ProcessUsingSpringBoard() const { return (m_flags & eMachProcessFlagsUsingSBS) != 0; } 268 bool ProcessUsingBackBoard() const { return (m_flags & eMachProcessFlagsUsingBKS) != 0; } 269 270 DNBProfileDataScanType GetProfileScanType () { return m_profile_scan_type; } 271 272 private: 273 enum 274 { 275 eMachProcessFlagsNone = 0, 276 eMachProcessFlagsAttached = (1 << 0), 277 eMachProcessFlagsUsingSBS = (1 << 1), 278 eMachProcessFlagsUsingBKS = (1 << 2) 279 }; 280 void Clear (bool detaching = false); 281 void ReplyToAllExceptions (); 282 void PrivateResume (); 283 284 uint32_t Flags () const { return m_flags; } 285 nub_state_t DoSIGSTOP (bool clear_bps_and_wps, bool allow_running, uint32_t *thread_idx_ptr); 286 287 pid_t m_pid; // Process ID of child process 288 cpu_type_t m_cpu_type; // The CPU type of this process 289 int m_child_stdin; 290 int m_child_stdout; 291 int m_child_stderr; 292 std::string m_path; // A path to the executable if we have one 293 std::vector<std::string> m_args; // The arguments with which the process was lauched 294 int m_exit_status; // The exit status for the process 295 std::string m_exit_info; // Any extra info that we may have about the exit 296 MachTask m_task; // The mach task for this process 297 uint32_t m_flags; // Process specific flags (see eMachProcessFlags enums) 298 uint32_t m_stop_count; // A count of many times have we stopped 299 pthread_t m_stdio_thread; // Thread ID for the thread that watches for child process stdio 300 PThreadMutex m_stdio_mutex; // Multithreaded protection for stdio 301 std::string m_stdout_data; 302 303 bool m_profile_enabled; // A flag to indicate if profiling is enabled 304 uint64_t m_profile_interval_usec; // If enable, the profiling interval in microseconds 305 DNBProfileDataScanType m_profile_scan_type; // Indicates what needs to be profiled 306 pthread_t m_profile_thread; // Thread ID for the thread that profiles the inferior 307 PThreadMutex m_profile_data_mutex; // Multithreaded protection for profile info data 308 std::vector<std::string> m_profile_data; // Profile data, must be protected by m_profile_data_mutex 309 310 DNBThreadResumeActions m_thread_actions; // The thread actions for the current MachProcess::Resume() call 311 MachException::Message::collection 312 m_exception_messages; // A collection of exception messages caught when listening to the exception port 313 PThreadMutex m_exception_messages_mutex; // Multithreaded protection for m_exception_messages 314 315 MachThreadList m_thread_list; // A list of threads that is maintained/updated after each stop 316 nub_state_t m_state; // The state of our process 317 PThreadMutex m_state_mutex; // Multithreaded protection for m_state 318 PThreadEvent m_events; // Process related events in the child processes lifetime can be waited upon 319 PThreadEvent m_private_events; // Used to coordinate running and stopping the process without affecting m_events 320 DNBBreakpointList m_breakpoints; // Breakpoint list for this process 321 DNBBreakpointList m_watchpoints; // Watchpoint list for this process 322 DNBCallbackNameToAddress m_name_to_addr_callback; 323 void * m_name_to_addr_baton; 324 DNBCallbackCopyExecutableImageInfos 325 m_image_infos_callback; 326 void * m_image_infos_baton; 327 std::string m_bundle_id; // If we are a SB or BKS process, this will be our bundle ID. 328 bool m_did_exec; 329 }; 330 331 332 #endif // __MachProcess_h__ 333