1 //===-- MachProcess.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-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Created by Greg Clayton on 6/15/07. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef __MachProcess_h__ 14 #define __MachProcess_h__ 15 16 #include <CoreFoundation/CoreFoundation.h> 17 #include <mach-o/loader.h> 18 #include <mach/mach.h> 19 #include <pthread.h> 20 #include <sys/signal.h> 21 #include <uuid/uuid.h> 22 #include <vector> 23 24 #include "DNBBreakpoint.h" 25 #include "DNBDefs.h" 26 #include "DNBError.h" 27 #include "DNBThreadResumeActions.h" 28 #include "Genealogy.h" 29 #include "JSONGenerator.h" 30 #include "MachException.h" 31 #include "MachTask.h" 32 #include "MachThreadList.h" 33 #include "MachVMMemory.h" 34 #include "PThreadCondition.h" 35 #include "PThreadEvent.h" 36 #include "PThreadMutex.h" 37 #include "ThreadInfo.h" 38 39 class DNBThreadResumeActions; 40 41 class MachProcess { 42 public: 43 //---------------------------------------------------------------------- 44 // Constructors and Destructors 45 //---------------------------------------------------------------------- 46 MachProcess(); 47 ~MachProcess(); 48 49 // A structure that can hold everything debugserver needs to know from 50 // a binary's Mach-O header / load commands. 51 52 struct mach_o_segment { 53 std::string name; 54 uint64_t vmaddr; 55 uint64_t vmsize; 56 uint64_t fileoff; 57 uint64_t filesize; 58 uint64_t maxprot; 59 uint64_t initprot; 60 uint64_t nsects; 61 uint64_t flags; 62 }; 63 64 struct mach_o_information { 65 struct mach_header_64 mach_header; 66 std::vector<struct mach_o_segment> segments; 67 uuid_t uuid; 68 std::string min_version_os_name; 69 std::string min_version_os_version; 70 }; 71 72 struct binary_image_information { 73 std::string filename; 74 uint64_t load_address; 75 uint64_t mod_date; // may not be available - 0 if so 76 struct mach_o_information macho_info; 77 78 binary_image_information() 79 : filename(), load_address(INVALID_NUB_ADDRESS), mod_date(0) {} 80 }; 81 82 //---------------------------------------------------------------------- 83 // Child process control 84 //---------------------------------------------------------------------- 85 pid_t AttachForDebug(pid_t pid, char *err_str, size_t err_len); 86 pid_t LaunchForDebug(const char *path, char const *argv[], char const *envp[], 87 const char *working_directory, const char *stdin_path, 88 const char *stdout_path, const char *stderr_path, 89 bool no_stdio, nub_launch_flavor_t launch_flavor, 90 int disable_aslr, const char *event_data, DNBError &err); 91 92 static uint32_t GetCPUTypeForLocalProcess(pid_t pid); 93 static pid_t ForkChildForPTraceDebugging(const char *path, char const *argv[], 94 char const *envp[], 95 MachProcess *process, DNBError &err); 96 static pid_t PosixSpawnChildForPTraceDebugging( 97 const char *path, cpu_type_t cpu_type, char const *argv[], 98 char const *envp[], const char *working_directory, const char *stdin_path, 99 const char *stdout_path, const char *stderr_path, bool no_stdio, 100 MachProcess *process, int disable_aslr, DNBError &err); 101 nub_addr_t GetDYLDAllImageInfosAddress(); 102 static const void *PrepareForAttach(const char *path, 103 nub_launch_flavor_t launch_flavor, 104 bool waitfor, DNBError &err_str); 105 static void CleanupAfterAttach(const void *attach_token, 106 nub_launch_flavor_t launch_flavor, 107 bool success, DNBError &err_str); 108 static nub_process_t CheckForProcess(const void *attach_token, 109 nub_launch_flavor_t launch_flavor); 110 #if defined(WITH_BKS) || defined(WITH_FBS) 111 pid_t BoardServiceLaunchForDebug(const char *app_bundle_path, 112 char const *argv[], char const *envp[], 113 bool no_stdio, bool disable_aslr, 114 const char *event_data, 115 DNBError &launch_err); 116 pid_t BoardServiceForkChildForPTraceDebugging( 117 const char *path, char const *argv[], char const *envp[], bool no_stdio, 118 bool disable_aslr, const char *event_data, DNBError &launch_err); 119 bool BoardServiceSendEvent(const char *event, DNBError &error); 120 #endif 121 static bool GetOSVersionNumbers(uint64_t *major, uint64_t *minor, 122 uint64_t *patch); 123 #ifdef WITH_BKS 124 static void BKSCleanupAfterAttach(const void *attach_token, 125 DNBError &err_str); 126 #endif // WITH_BKS 127 #ifdef WITH_FBS 128 static void FBSCleanupAfterAttach(const void *attach_token, 129 DNBError &err_str); 130 #endif // WITH_FBS 131 #ifdef WITH_SPRINGBOARD 132 pid_t SBLaunchForDebug(const char *app_bundle_path, char const *argv[], 133 char const *envp[], bool no_stdio, bool disable_aslr, 134 DNBError &launch_err); 135 static pid_t SBForkChildForPTraceDebugging(const char *path, 136 char const *argv[], 137 char const *envp[], bool no_stdio, 138 MachProcess *process, 139 DNBError &launch_err); 140 #endif // WITH_SPRINGBOARD 141 nub_addr_t LookupSymbol(const char *name, const char *shlib); 142 void SetNameToAddressCallback(DNBCallbackNameToAddress callback, 143 void *baton) { 144 m_name_to_addr_callback = callback; 145 m_name_to_addr_baton = baton; 146 } 147 void 148 SetSharedLibraryInfoCallback(DNBCallbackCopyExecutableImageInfos callback, 149 void *baton) { 150 m_image_infos_callback = callback; 151 m_image_infos_baton = baton; 152 } 153 154 bool Resume(const DNBThreadResumeActions &thread_actions); 155 bool Signal(int signal, const struct timespec *timeout_abstime = NULL); 156 bool Interrupt(); 157 bool SendEvent(const char *event, DNBError &send_err); 158 bool Kill(const struct timespec *timeout_abstime = NULL); 159 bool Detach(); 160 nub_size_t ReadMemory(nub_addr_t addr, nub_size_t size, void *buf); 161 nub_size_t WriteMemory(nub_addr_t addr, nub_size_t size, const void *buf); 162 163 //---------------------------------------------------------------------- 164 // Path and arg accessors 165 //---------------------------------------------------------------------- 166 const char *Path() const { return m_path.c_str(); } 167 size_t ArgumentCount() const { return m_args.size(); } 168 const char *ArgumentAtIndex(size_t arg_idx) const { 169 if (arg_idx < m_args.size()) 170 return m_args[arg_idx].c_str(); 171 return NULL; 172 } 173 174 //---------------------------------------------------------------------- 175 // Breakpoint functions 176 //---------------------------------------------------------------------- 177 DNBBreakpoint *CreateBreakpoint(nub_addr_t addr, nub_size_t length, 178 bool hardware); 179 bool DisableBreakpoint(nub_addr_t addr, bool remove); 180 void DisableAllBreakpoints(bool remove); 181 bool EnableBreakpoint(nub_addr_t addr); 182 DNBBreakpointList &Breakpoints() { return m_breakpoints; } 183 const DNBBreakpointList &Breakpoints() const { return m_breakpoints; } 184 185 //---------------------------------------------------------------------- 186 // Watchpoint functions 187 //---------------------------------------------------------------------- 188 DNBBreakpoint *CreateWatchpoint(nub_addr_t addr, nub_size_t length, 189 uint32_t watch_type, bool hardware); 190 bool DisableWatchpoint(nub_addr_t addr, bool remove); 191 void DisableAllWatchpoints(bool remove); 192 bool EnableWatchpoint(nub_addr_t addr); 193 uint32_t GetNumSupportedHardwareWatchpoints() const; 194 DNBBreakpointList &Watchpoints() { return m_watchpoints; } 195 const DNBBreakpointList &Watchpoints() const { return m_watchpoints; } 196 197 //---------------------------------------------------------------------- 198 // Exception thread functions 199 //---------------------------------------------------------------------- 200 bool StartSTDIOThread(); 201 static void *STDIOThread(void *arg); 202 void ExceptionMessageReceived(const MachException::Message &exceptionMessage); 203 task_t ExceptionMessageBundleComplete(); 204 void SharedLibrariesUpdated(); 205 nub_size_t CopyImageInfos(struct DNBExecutableImageInfo **image_infos, 206 bool only_changed); 207 208 //---------------------------------------------------------------------- 209 // Profile functions 210 //---------------------------------------------------------------------- 211 void SetEnableAsyncProfiling(bool enable, uint64_t internal_usec, 212 DNBProfileDataScanType scan_type); 213 bool IsProfilingEnabled() { return m_profile_enabled; } 214 useconds_t ProfileInterval() { return m_profile_interval_usec; } 215 bool StartProfileThread(); 216 static void *ProfileThread(void *arg); 217 void SignalAsyncProfileData(const char *info); 218 size_t GetAsyncProfileData(char *buf, size_t buf_size); 219 220 //---------------------------------------------------------------------- 221 // Accessors 222 //---------------------------------------------------------------------- 223 pid_t ProcessID() const { return m_pid; } 224 bool ProcessIDIsValid() const { return m_pid > 0; } 225 pid_t SetProcessID(pid_t pid); 226 MachTask &Task() { return m_task; } 227 const MachTask &Task() const { return m_task; } 228 229 PThreadEvent &Events() { return m_events; } 230 const DNBRegisterSetInfo *GetRegisterSetInfo(nub_thread_t tid, 231 nub_size_t *num_reg_sets) const; 232 bool GetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg, 233 DNBRegisterValue *reg_value) const; 234 bool SetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg, 235 const DNBRegisterValue *value) const; 236 nub_bool_t SyncThreadState(nub_thread_t tid); 237 const char *ThreadGetName(nub_thread_t tid); 238 nub_state_t ThreadGetState(nub_thread_t tid); 239 ThreadInfo::QoS GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd, 240 uint64_t dti_qos_class_index); 241 nub_addr_t GetPThreadT(nub_thread_t tid); 242 nub_addr_t GetDispatchQueueT(nub_thread_t tid); 243 nub_addr_t 244 GetTSDAddressForThread(nub_thread_t tid, 245 uint64_t plo_pthread_tsd_base_address_offset, 246 uint64_t plo_pthread_tsd_base_offset, 247 uint64_t plo_pthread_tsd_entry_size); 248 const char * 249 GetDeploymentInfo(const struct load_command&, uint64_t load_command_address, 250 uint32_t& major_version, uint32_t& minor_version, 251 uint32_t& patch_version); 252 bool GetMachOInformationFromMemory(nub_addr_t mach_o_header_addr, 253 int wordsize, 254 struct mach_o_information &inf); 255 JSONGenerator::ObjectSP FormatDynamicLibrariesIntoJSON( 256 const std::vector<struct binary_image_information> &image_infos); 257 void GetAllLoadedBinariesViaDYLDSPI( 258 std::vector<struct binary_image_information> &image_infos); 259 JSONGenerator::ObjectSP GetLoadedDynamicLibrariesInfos( 260 nub_process_t pid, nub_addr_t image_list_address, nub_addr_t image_count); 261 JSONGenerator::ObjectSP 262 GetLibrariesInfoForAddresses(nub_process_t pid, 263 std::vector<uint64_t> &macho_addresses); 264 JSONGenerator::ObjectSP GetAllLoadedLibrariesInfos(nub_process_t pid); 265 JSONGenerator::ObjectSP GetSharedCacheInfo(nub_process_t pid); 266 267 nub_size_t GetNumThreads() const; 268 nub_thread_t GetThreadAtIndex(nub_size_t thread_idx) const; 269 nub_thread_t GetCurrentThread(); 270 nub_thread_t GetCurrentThreadMachPort(); 271 nub_thread_t SetCurrentThread(nub_thread_t tid); 272 MachThreadList &GetThreadList() { return m_thread_list; } 273 bool GetThreadStoppedReason(nub_thread_t tid, 274 struct DNBThreadStopInfo *stop_info); 275 void DumpThreadStoppedReason(nub_thread_t tid) const; 276 const char *GetThreadInfo(nub_thread_t tid) const; 277 278 nub_thread_t GetThreadIDForMachPortNumber(thread_t mach_port_number) const; 279 280 uint32_t GetCPUType(); 281 nub_state_t GetState(); 282 void SetState(nub_state_t state); 283 bool IsRunning(nub_state_t state) { 284 return state == eStateRunning || IsStepping(state); 285 } 286 bool IsStepping(nub_state_t state) { return state == eStateStepping; } 287 bool CanResume(nub_state_t state) { return state == eStateStopped; } 288 289 bool GetExitStatus(int *status) { 290 if (GetState() == eStateExited) { 291 if (status) 292 *status = m_exit_status; 293 return true; 294 } 295 return false; 296 } 297 void SetExitStatus(int status) { 298 m_exit_status = status; 299 SetState(eStateExited); 300 } 301 const char *GetExitInfo() { return m_exit_info.c_str(); } 302 303 void SetExitInfo(const char *info); 304 305 uint32_t StopCount() const { return m_stop_count; } 306 void SetChildFileDescriptors(int stdin_fileno, int stdout_fileno, 307 int stderr_fileno) { 308 m_child_stdin = stdin_fileno; 309 m_child_stdout = stdout_fileno; 310 m_child_stderr = stderr_fileno; 311 } 312 313 int GetStdinFileDescriptor() const { return m_child_stdin; } 314 int GetStdoutFileDescriptor() const { return m_child_stdout; } 315 int GetStderrFileDescriptor() const { return m_child_stderr; } 316 void AppendSTDOUT(char *s, size_t len); 317 size_t GetAvailableSTDOUT(char *buf, size_t buf_size); 318 size_t GetAvailableSTDERR(char *buf, size_t buf_size); 319 void CloseChildFileDescriptors() { 320 if (m_child_stdin >= 0) { 321 ::close(m_child_stdin); 322 m_child_stdin = -1; 323 } 324 if (m_child_stdout >= 0) { 325 ::close(m_child_stdout); 326 m_child_stdout = -1; 327 } 328 if (m_child_stderr >= 0) { 329 ::close(m_child_stderr); 330 m_child_stderr = -1; 331 } 332 } 333 334 void CalculateBoardStatus(); 335 336 bool ProcessUsingBackBoard(); 337 338 bool ProcessUsingFrontBoard(); 339 340 Genealogy::ThreadActivitySP GetGenealogyInfoForThread(nub_thread_t tid, 341 bool &timed_out); 342 343 Genealogy::ProcessExecutableInfoSP GetGenealogyImageInfo(size_t idx); 344 345 DNBProfileDataScanType GetProfileScanType() { return m_profile_scan_type; } 346 347 private: 348 enum { 349 eMachProcessFlagsNone = 0, 350 eMachProcessFlagsAttached = (1 << 0), 351 eMachProcessFlagsUsingBKS = (1 << 2), // only read via ProcessUsingBackBoard() 352 eMachProcessFlagsUsingFBS = (1 << 3), // only read via ProcessUsingFrontBoard() 353 eMachProcessFlagsBoardCalculated = (1 << 4) 354 }; 355 void Clear(bool detaching = false); 356 void ReplyToAllExceptions(); 357 void PrivateResume(); 358 359 uint32_t Flags() const { return m_flags; } 360 nub_state_t DoSIGSTOP(bool clear_bps_and_wps, bool allow_running, 361 uint32_t *thread_idx_ptr); 362 363 pid_t m_pid; // Process ID of child process 364 cpu_type_t m_cpu_type; // The CPU type of this process 365 int m_child_stdin; 366 int m_child_stdout; 367 int m_child_stderr; 368 std::string m_path; // A path to the executable if we have one 369 std::vector<std::string> 370 m_args; // The arguments with which the process was lauched 371 int m_exit_status; // The exit status for the process 372 std::string m_exit_info; // Any extra info that we may have about the exit 373 MachTask m_task; // The mach task for this process 374 uint32_t m_flags; // Process specific flags (see eMachProcessFlags enums) 375 uint32_t m_stop_count; // A count of many times have we stopped 376 pthread_t m_stdio_thread; // Thread ID for the thread that watches for child 377 // process stdio 378 PThreadMutex m_stdio_mutex; // Multithreaded protection for stdio 379 std::string m_stdout_data; 380 381 bool m_profile_enabled; // A flag to indicate if profiling is enabled 382 useconds_t m_profile_interval_usec; // If enable, the profiling interval in 383 // microseconds 384 DNBProfileDataScanType 385 m_profile_scan_type; // Indicates what needs to be profiled 386 pthread_t 387 m_profile_thread; // Thread ID for the thread that profiles the inferior 388 PThreadMutex 389 m_profile_data_mutex; // Multithreaded protection for profile info data 390 std::vector<std::string> 391 m_profile_data; // Profile data, must be protected by m_profile_data_mutex 392 393 DNBThreadResumeActions m_thread_actions; // The thread actions for the current 394 // MachProcess::Resume() call 395 MachException::Message::collection m_exception_messages; // A collection of 396 // exception messages 397 // caught when 398 // listening to the 399 // exception port 400 PThreadMutex m_exception_messages_mutex; // Multithreaded protection for 401 // m_exception_messages 402 403 MachThreadList m_thread_list; // A list of threads that is maintained/updated 404 // after each stop 405 Genealogy m_activities; // A list of activities that is updated after every 406 // stop lazily 407 nub_state_t m_state; // The state of our process 408 PThreadMutex m_state_mutex; // Multithreaded protection for m_state 409 PThreadEvent m_events; // Process related events in the child processes 410 // lifetime can be waited upon 411 PThreadEvent m_private_events; // Used to coordinate running and stopping the 412 // process without affecting m_events 413 DNBBreakpointList m_breakpoints; // Breakpoint list for this process 414 DNBBreakpointList m_watchpoints; // Watchpoint list for this process 415 DNBCallbackNameToAddress m_name_to_addr_callback; 416 void *m_name_to_addr_baton; 417 DNBCallbackCopyExecutableImageInfos m_image_infos_callback; 418 void *m_image_infos_baton; 419 std::string 420 m_bundle_id; // If we are a SB or BKS process, this will be our bundle ID. 421 int m_sent_interrupt_signo; // When we call MachProcess::Interrupt(), we want 422 // to send a single signal 423 // to the inferior and only send the signal if we aren't already stopped. 424 // If we end up sending a signal to stop the process we store it until we 425 // receive an exception with this signal. This helps us to verify we got 426 // the signal that interrupted the process. We might stop due to another 427 // reason after an interrupt signal is sent, so this helps us ensure that 428 // we don't report a spurious stop on the next resume. 429 int m_auto_resume_signo; // If we resume the process and still haven't 430 // received our interrupt signal 431 // acknownledgement, we will shortly after the next resume. We store the 432 // interrupt signal in this variable so when we get the interrupt signal 433 // as the sole reason for the process being stopped, we can auto resume 434 // the process. 435 bool m_did_exec; 436 437 void *(*m_dyld_process_info_create)(task_t task, uint64_t timestamp, 438 kern_return_t *kernelError); 439 void (*m_dyld_process_info_for_each_image)( 440 void *info, void (^callback)(uint64_t machHeaderAddress, 441 const uuid_t uuid, const char *path)); 442 void (*m_dyld_process_info_release)(void *info); 443 void (*m_dyld_process_info_get_cache)(void *info, void *cacheInfo); 444 }; 445 446 #endif // __MachProcess_h__ 447