124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//===-- MachProcess.cpp -----------------------------------------*- C++ -*-===// 224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// 324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// The LLVM Compiler Infrastructure 424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// 524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// This file is distributed under the University of Illinois Open Source 624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// License. See LICENSE.TXT for details. 724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// 824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//===----------------------------------------------------------------------===// 924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// 1024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Created by Greg Clayton on 6/15/07. 1124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// 1224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//===----------------------------------------------------------------------===// 1324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "DNB.h" 1544eb9fb021023027159df55f91c3e95384088970Jason Molenda#include <inttypes.h> 1624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <mach/mach.h> 17c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton#include <signal.h> 1824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <spawn.h> 1924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <sys/fcntl.h> 2024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <sys/types.h> 2124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <sys/ptrace.h> 2224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <sys/stat.h> 23a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton#include <sys/sysctl.h> 2424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <unistd.h> 2524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "MacOSX/CFUtils.h" 2624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "SysSignal.h" 2724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 2824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <algorithm> 2924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <map> 3024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 3124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "DNBDataRef.h" 3224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "DNBLog.h" 3324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "DNBThreadResumeActions.h" 3424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "DNBTimer.h" 3524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "MachProcess.h" 3624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "PseudoTerminal.h" 3724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 3824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "CFBundle.h" 3924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "CFData.h" 4024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include "CFString.h" 4124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 4224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerstatic CFStringRef CopyBundleIDForPath (const char *app_buncle_path, DNBError &err_str); 4324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 449a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 4524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 4624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <CoreFoundation/CoreFoundation.h> 4724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <SpringBoardServices/SpringBoardServer.h> 4824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <SpringBoardServices/SBSWatchdogAssertion.h> 4924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 5024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerstatic bool 5124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerIsSBProcess (nub_process_t pid) 5224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 5356b9f80df238c8be09d2b7441e9e71f7828bbd3aJim Ingham CFReleaser<CFArrayRef> appIdsForPID (::SBSCopyDisplayIdentifiersForProcessID(pid)); 5456b9f80df238c8be09d2b7441e9e71f7828bbd3aJim Ingham return appIdsForPID.get() != NULL; 5524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 5624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 5724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 5824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 5924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#if 0 6024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#define DEBUG_LOG(fmt, ...) printf(fmt, ## __VA_ARGS__) 6124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#else 6224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#define DEBUG_LOG(fmt, ...) 6324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 6424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 6524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#ifndef MACH_PROCESS_USE_POSIX_SPAWN 6624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#define MACH_PROCESS_USE_POSIX_SPAWN 1 6724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 6824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 69452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton#ifndef _POSIX_SPAWN_DISABLE_ASLR 70452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton#define _POSIX_SPAWN_DISABLE_ASLR 0x0100 71452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton#endif 7224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 7324943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::MachProcess() : 7424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid (0), 75a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton m_cpu_type (0), 7624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_child_stdin (-1), 7724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_child_stdout (-1), 7824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_child_stderr (-1), 7924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_path (), 8024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_args (), 8124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_task (this), 8224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags (eMachProcessFlagsNone), 8324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdio_thread (0), 8424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdio_mutex (PTHREAD_MUTEX_RECURSIVE), 8524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdout_data (), 86c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions (), 87fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_enabled (false), 88fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_interval_usec (0), 89fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_thread (0), 90fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE), 91fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_data (), 923b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list (), 9324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages (), 9424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages_mutex (PTHREAD_MUTEX_RECURSIVE), 9524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_state (eStateUnloaded), 9624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_state_mutex (PTHREAD_MUTEX_RECURSIVE), 9724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events (0, kAllEventsMask), 98cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton m_private_events (0, kAllEventsMask), 9924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_breakpoints (), 10024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_watchpoints (), 10124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_name_to_addr_callback(NULL), 10224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_name_to_addr_baton(NULL), 10324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_image_infos_callback(NULL), 1044d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_image_infos_baton(NULL), 1054d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_did_exec (false) 10624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 10724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__); 10824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 10924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 11024943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::~MachProcess() 11124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 11224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__); 11324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 11424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 11524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 11624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 11724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::SetProcessID(pid_t pid) 11824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 11924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Free any previous process specific data or resources 12024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 12124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Set the current PID appropriately 12224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pid == 0) 123fa1502444821fb699b14883bd24188c85a8793e0Johnny Chen m_pid = ::getpid (); 12424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 12524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = pid; 12624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_pid; // Return actualy PID in case a zero pid was passed in 12724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 12824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 12924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_state_t 13024943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetState() 13124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 13224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If any other threads access this we will need a mutex for it 13324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER(locker, m_state_mutex); 13424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_state; 13524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 13624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 13724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerconst char * 13824943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ThreadGetName(nub_thread_t tid) 13924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1403b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.GetName(tid); 14124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 14224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 14324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_state_t 14424943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ThreadGetState(nub_thread_t tid) 14524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1463b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.GetState(tid); 14724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 14824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 14924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 15024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_size_t 15124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetNumThreads () const 15224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1533b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.NumThreads(); 15424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 15524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 15624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_thread_t 15724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetThreadAtIndex (nub_size_t thread_idx) const 15824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1593b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.ThreadIDAtIndex(thread_idx); 16024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 16124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 16244eb9fb021023027159df55f91c3e95384088970Jason Molendanub_thread_t 16344eb9fb021023027159df55f91c3e95384088970Jason MolendaMachProcess::GetThreadIDForMachPortNumber (thread_t mach_port_number) const 16444eb9fb021023027159df55f91c3e95384088970Jason Molenda{ 16544eb9fb021023027159df55f91c3e95384088970Jason Molenda return m_thread_list.GetThreadIDByMachPortNumber (mach_port_number); 16644eb9fb021023027159df55f91c3e95384088970Jason Molenda} 16744eb9fb021023027159df55f91c3e95384088970Jason Molenda 16873f6b49b568f48755bb5058a3db679c3b9093682Jim Inghamnub_bool_t 16973f6b49b568f48755bb5058a3db679c3b9093682Jim InghamMachProcess::SyncThreadState (nub_thread_t tid) 17073f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham{ 17173f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid)); 17273f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham if (!thread_sp) 17373f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham return false; 17444eb9fb021023027159df55f91c3e95384088970Jason Molenda kern_return_t kret = ::thread_abort_safely(thread_sp->MachPortNumber()); 17544eb9fb021023027159df55f91c3e95384088970Jason Molenda DNBLogThreadedIf (LOG_THREAD, "thread = 0x%8.8" PRIx32 " calling thread_abort_safely (tid) => %u (GetGPRState() for stop_count = %u)", thread_sp->MachPortNumber(), kret, thread_sp->Process()->StopCount()); 17673f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham 17773f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham if (kret == KERN_SUCCESS) 17873f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham return true; 17973f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham else 18073f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham return false; 18173f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham 18273f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham} 18373f6b49b568f48755bb5058a3db679c3b9093682Jim Ingham 18424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_thread_t 18524943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetCurrentThread () 18624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1873b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.CurrentThreadID(); 18824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 18924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 19024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_thread_t 191afe3763f13dc122006ad6b5ed377e789e09c8715Jason MolendaMachProcess::GetCurrentThreadMachPort () 192afe3763f13dc122006ad6b5ed377e789e09c8715Jason Molenda{ 193afe3763f13dc122006ad6b5ed377e789e09c8715Jason Molenda return m_thread_list.GetMachPortNumberByThreadID(m_thread_list.CurrentThreadID()); 194afe3763f13dc122006ad6b5ed377e789e09c8715Jason Molenda} 195afe3763f13dc122006ad6b5ed377e789e09c8715Jason Molenda 196afe3763f13dc122006ad6b5ed377e789e09c8715Jason Molendanub_thread_t 19724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::SetCurrentThread(nub_thread_t tid) 19824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1993b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.SetCurrentThread(tid); 20024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 20124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 20224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 2034d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg ClaytonMachProcess::GetThreadStoppedReason(nub_thread_t tid, struct DNBThreadStopInfo *stop_info) 20424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 2054d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_thread_list.GetThreadStoppedReason(tid, stop_info)) 2064d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 2074d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_did_exec) 2084d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton stop_info->reason = eStopTypeExec; 2094d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton return true; 2104d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 2114d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton return false; 21224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 21324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 21424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 21524943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::DumpThreadStoppedReason(nub_thread_t tid) const 21624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 2173b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.DumpThreadStoppedReason(tid); 21824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 21924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 22024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerconst char * 22124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetThreadInfo(nub_thread_t tid) const 22224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 2233b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.GetThreadInfo(tid); 22424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 22524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 226a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Claytonuint32_t 227a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg ClaytonMachProcess::GetCPUType () 228a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton{ 229a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (m_cpu_type == 0 && m_pid != 0) 230a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton m_cpu_type = MachProcess::GetCPUTypeForLocalProcess (m_pid); 231a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton return m_cpu_type; 232a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton} 233a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton 23424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerconst DNBRegisterSetInfo * 23561468e816e879874ee8499ce5a1b4f1d6759b026Greg ClaytonMachProcess::GetRegisterSetInfo (nub_thread_t tid, nub_size_t *num_reg_sets) const 23624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 23761468e816e879874ee8499ce5a1b4f1d6759b026Greg Clayton MachThreadSP thread_sp (m_thread_list.GetThreadByID (tid)); 23861468e816e879874ee8499ce5a1b4f1d6759b026Greg Clayton if (thread_sp) 23920d338fad87eba91de65aa9bec76e01c04472848Greg Clayton { 24061468e816e879874ee8499ce5a1b4f1d6759b026Greg Clayton DNBArchProtocol *arch = thread_sp->GetArchProtocol(); 24120d338fad87eba91de65aa9bec76e01c04472848Greg Clayton if (arch) 24220d338fad87eba91de65aa9bec76e01c04472848Greg Clayton return arch->GetRegisterSetInfo (num_reg_sets); 24320d338fad87eba91de65aa9bec76e01c04472848Greg Clayton } 24420d338fad87eba91de65aa9bec76e01c04472848Greg Clayton *num_reg_sets = 0; 24520d338fad87eba91de65aa9bec76e01c04472848Greg Clayton return NULL; 24624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 24724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 24824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 24924943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetRegisterValue ( nub_thread_t tid, uint32_t set, uint32_t reg, DNBRegisterValue *value ) const 25024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 2513b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.GetRegisterValue(tid, set, reg, value); 25224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 25324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 25424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 25524943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::SetRegisterValue ( nub_thread_t tid, uint32_t set, uint32_t reg, const DNBRegisterValue *value ) const 25624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 2573b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return m_thread_list.SetRegisterValue(tid, set, reg, value); 25824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 25924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 26024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 26124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::SetState(nub_state_t new_state) 26224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 26324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If any other threads access this we will need a mutex for it 26424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner uint32_t event_mask = 0; 26524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 26624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Scope for mutex locker 26724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 26824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER(locker, m_state_mutex); 26924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const nub_state_t old_state = m_state; 27024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 27158274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton if (old_state == eStateExited) 27258274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton { 27358274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) ignoring new state since current state is exited", DNBStateAsString(new_state)); 27458274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton } 27558274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton else if (old_state == new_state) 27658274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton { 27758274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) ignoring redundant state change...", DNBStateAsString(new_state)); 27858274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton } 27958274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton else 28024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 28124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (NUB_STATE_IS_STOPPED(new_state)) 28224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner event_mask = eEventProcessStoppedStateChanged; 28324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 28424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner event_mask = eEventProcessRunningStateChanged; 28524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 28658274a3c8d618e5aac2b738aa1d11bce423208abGreg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) upating state (previous state was %s), event_mask = 0x%8.8x", DNBStateAsString(new_state), DNBStateAsString(old_state), event_mask); 287cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton 28824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_state = new_state; 28924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (new_state == eStateStopped) 29024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stop_count++; 29124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 29224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 29324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 29424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (event_mask != 0) 29524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 29624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.SetEvents (event_mask); 297cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton m_private_events.SetEvents (event_mask); 298cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton if (event_mask == eEventProcessStoppedStateChanged) 299cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton m_private_events.ResetEvents (eEventProcessRunningStateChanged); 300cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton else 301cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton m_private_events.ResetEvents (eEventProcessStoppedStateChanged); 30224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 30324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Wait for the event bit to reset if a reset ACK is requested 30424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.WaitForResetAck(event_mask); 30524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 30624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 30724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 30824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 30924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 31024943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::Clear() 31124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 31224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear any cached thread list while the pid and task are still valid 31324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 31424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_task.Clear(); 31524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Now clear out all member variables 31624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = INVALID_NUB_PROCESS; 31724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CloseChildFileDescriptors(); 31824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_path.clear(); 31924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_args.clear(); 32024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState(eStateUnloaded); 32124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags = eMachProcessFlagsNone; 32224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stop_count = 0; 3233b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.Clear(); 32424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 32524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex); 32624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages.clear(); 32724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 328fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong if (m_profile_thread) 329fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 330fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong pthread_join(m_profile_thread, NULL); 331fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_thread = NULL; 332fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 33324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 33424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 33524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 33624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 33724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::StartSTDIOThread() 33824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 33924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__); 34024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Create the thread that watches for the child STDIO 34135c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return ::pthread_create (&m_stdio_thread, NULL, MachProcess::STDIOThread, this) == 0; 34224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 34324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 344fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ongvoid 345cec43ab7f30085ac7f65a26a58b956a69e363a3bHan Ming OngMachProcess::SetEnableAsyncProfiling(bool enable, uint64_t interval_usec, DNBProfileDataScanType scan_type) 346fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong{ 347fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_enabled = enable; 348fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_profile_interval_usec = interval_usec; 349cec43ab7f30085ac7f65a26a58b956a69e363a3bHan Ming Ong m_profile_scan_type = scan_type; 350fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 351b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong if (m_profile_enabled && (m_profile_thread == NULL)) 352fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 353fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong StartProfileThread(); 354fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 355b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong else if (!m_profile_enabled && m_profile_thread) 356b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong { 357b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong pthread_join(m_profile_thread, NULL); 358b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong m_profile_thread = NULL; 359b989d7878062ff854ff212524ac694b3e1dacbe2Han Ming Ong } 360fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong} 361fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 362fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ongbool 363fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming OngMachProcess::StartProfileThread() 364fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong{ 365fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__); 366fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong // Create the thread that profiles the inferior and reports back if enabled 367fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong return ::pthread_create (&m_profile_thread, NULL, MachProcess::ProfileThread, this) == 0; 368fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong} 369fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 37024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 37124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_addr_t 37224943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::LookupSymbol(const char *name, const char *shlib) 37324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 37424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_name_to_addr_callback != NULL && name && name[0]) 37524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_name_to_addr_callback(ProcessID(), name, shlib, m_name_to_addr_baton); 37624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_ADDRESS; 37724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 37824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 37924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 38024943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::Resume (const DNBThreadResumeActions& thread_actions) 38124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 38224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Resume ()"); 38324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_state_t state = GetState(); 38424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 38524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (CanResume(state)) 38624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 387c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions = thread_actions; 388c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton PrivateResume(); 38935c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return true; 39024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 39124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (state == eStateRunning) 39224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 3937ddd06257641c6386a0fd809cad42839597e17b9Greg Clayton DNBLog("Resume() - task 0x%x is already running, ignoring...", m_task.TaskPort()); 39435c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return true; 39524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 3967ddd06257641c6386a0fd809cad42839597e17b9Greg Clayton DNBLog("Resume() - task 0x%x has state %s, can't continue...", m_task.TaskPort(), DNBStateAsString(state)); 39735c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return false; 39824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 39924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 40024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 40124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::Kill (const struct timespec *timeout_abstime) 40224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 40324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill ()"); 404dff3f44e3970930a30ea50025436cb7272366911Jim Ingham nub_state_t state = DoSIGSTOP(true, false, NULL); 40524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() state = %s", DNBStateAsString(state)); 40624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner errno = 0; 4078492942e52539a5c4fb4c06a865ad8479d496340Jason Molenda DNBLog ("Sending ptrace PT_KILL to terminate inferior process."); 40824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::ptrace (PT_KILL, m_pid, 0, 0); 40935c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err; 41035c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.SetErrorToErrno(); 4110e8147bd867e4cdaae9400f56d02c7aacd40a9b3Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() ::ptrace (PT_KILL, pid=%u, 0, 0) => 0x%8.8x (%s)", m_pid, err.Error(), err.AsString()); 412c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions = DNBThreadResumeActions (eStateRunning, 0); 413c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton PrivateResume (); 414427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton 415427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton // Try and reap the process without touching our m_events since 416427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton // we want the code above this to still get the eStateExited event 417427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton const uint32_t reap_timeout_usec = 1000000; // Wait 1 second and try to reap the process 418427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton const uint32_t reap_interval_usec = 10000; // 419427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton uint32_t reap_time_elapsed; 420427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton for (reap_time_elapsed = 0; 421427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton reap_time_elapsed < reap_timeout_usec; 422427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton reap_time_elapsed += reap_interval_usec) 423427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton { 424427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton if (GetState() == eStateExited) 425427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton break; 426427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton usleep(reap_interval_usec); 427427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton } 428427b7e842d0ce6d2099a07fc13cdd0b9d7e9c12aGreg Clayton DNBLog ("Waited %u ms for process to be reaped (state = %s)", reap_time_elapsed/1000, DNBStateAsString(GetState())); 42924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 43024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 43124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 43224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 43324943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::Signal (int signal, const struct timespec *timeout_abstime) 43424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 43524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p)", signal, timeout_abstime); 43624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_state_t state = GetState(); 43724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (::kill (ProcessID(), signal) == 0) 43824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 43924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If we were running and we have a timeout, wait for the signal to stop 44024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (IsRunning(state) && timeout_abstime) 44124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 44224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) waiting for signal to stop process...", signal, timeout_abstime); 443cf9591fb271ec132c866d264ca21ff06a21841c7Greg Clayton m_private_events.WaitForSetEvents(eEventProcessStoppedStateChanged, timeout_abstime); 44424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner state = GetState(); 44524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal, timeout_abstime, DNBStateAsString(state)); 44624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return !IsRunning (state); 44724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 44824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout = %p) not waiting...", signal, timeout_abstime); 44935c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return true; 45024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 45135c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err(errno, DNBError::POSIX); 45235c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal); 45335c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return false; 45424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 45524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 45624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 45724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_state_t 458dff3f44e3970930a30ea50025436cb7272366911Jim InghamMachProcess::DoSIGSTOP (bool clear_bps_and_wps, bool allow_running, uint32_t *thread_idx_ptr) 45924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 46024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_state_t state = GetState(); 46124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s", DNBStateAsString (state)); 46224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 46324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (!IsRunning(state)) 46424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 46524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (clear_bps_and_wps) 46624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 46724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DisableAllBreakpoints (true); 46824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DisableAllWatchpoints (true); 46924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner clear_bps_and_wps = false; 47024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 47124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 4723b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton // If we already have a thread stopped due to a SIGSTOP, we don't have 4733b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton // to do anything... 47490b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice uint32_t thread_idx = m_thread_list.GetThreadIndexForThreadStoppedWithSignal (SIGSTOP); 47590b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice if (thread_idx_ptr) 47690b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice *thread_idx_ptr = thread_idx; 47790b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice if (thread_idx != UINT32_MAX) 4783b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton return GetState(); 4793b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton 4803b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton // No threads were stopped with a SIGSTOP, we need to run and halt the 4813b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton // process with a signal 48224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s -- resuming process", DNBStateAsString (state)); 483dff3f44e3970930a30ea50025436cb7272366911Jim Ingham if (allow_running) 484dff3f44e3970930a30ea50025436cb7272366911Jim Ingham m_thread_actions = DNBThreadResumeActions (eStateRunning, 0); 485dff3f44e3970930a30ea50025436cb7272366911Jim Ingham else 486dff3f44e3970930a30ea50025436cb7272366911Jim Ingham m_thread_actions = DNBThreadResumeActions (eStateSuspended, 0); 487dff3f44e3970930a30ea50025436cb7272366911Jim Ingham 488c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton PrivateResume (); 48924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 49024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Reset the event that says we were indeed running 49124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.ResetEvents(eEventProcessRunningStateChanged); 49224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner state = GetState(); 49324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 49424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 49524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We need to be stopped in order to be able to detach, so we need 49624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // to send ourselves a SIGSTOP 49724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 49824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s -- sending SIGSTOP", DNBStateAsString (state)); 49924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner struct timespec sigstop_timeout; 50024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBTimer::OffsetTimeOfDay(&sigstop_timeout, 2, 0); 50124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Signal (SIGSTOP, &sigstop_timeout); 50224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (clear_bps_and_wps) 50324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 50424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DisableAllBreakpoints (true); 50524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DisableAllWatchpoints (true); 5064a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton //clear_bps_and_wps = false; 50724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 50890b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice uint32_t thread_idx = m_thread_list.GetThreadIndexForThreadStoppedWithSignal (SIGSTOP); 50990b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice if (thread_idx_ptr) 51090b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice *thread_idx_ptr = thread_idx; 51124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return GetState(); 51224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 51324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 51424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 51524943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::Detach() 51624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 51724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach()"); 51824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 51990b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice uint32_t thread_idx = UINT32_MAX; 520dff3f44e3970930a30ea50025436cb7272366911Jim Ingham nub_state_t state = DoSIGSTOP(true, true, &thread_idx); 52124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach() DoSIGSTOP() returned %s", DNBStateAsString(state)); 52224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 5233b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton { 524c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions.Clear(); 52590b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice DNBThreadResumeAction thread_action; 52690b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice thread_action.tid = m_thread_list.ThreadIDAtIndex (thread_idx); 52790b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice thread_action.state = eStateRunning; 52890b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice thread_action.signal = -1; 52990b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice thread_action.addr = INVALID_NUB_ADDRESS; 53090b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice 531c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions.Append (thread_action); 532c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_actions.SetDefaultThreadActionIfNeeded (eStateRunning, 0); 53390b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice 5343b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex); 53524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 536c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton ReplyToAllExceptions (); 5373b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton 5383b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton } 53924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 5403b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_task.ShutDownExcecptionThread(); 54124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 54224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Detach from our process 54324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner errno = 0; 54424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_process_t pid = m_pid; 54590b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice int ret = ::ptrace (PT_DETACH, pid, (caddr_t)1, 0); 54635c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err(errno, DNBError::POSIX); 54790b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0)) 54835c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid); 54924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 55024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Resume our task 55124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_task.Resume(); 55224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 55324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // NULL our task out as we have already retored all exception ports 55424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_task.Clear(); 55524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 55624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear out any notion of the process we once were 55724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 5583b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton 5593b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton SetState(eStateDetached); 5603b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton 56124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 56224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 56324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 56424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//---------------------------------------------------------------------- 56524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// ReadMemory from the MachProcess level will always remove any software 56624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// breakpoints from the memory buffer before returning. If you wish to 56724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// read memory and see those traps, read from the MachTask 56824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// (m_task.ReadMemory()) as that version will give you what is actually 56924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// in inferior memory. 57024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//---------------------------------------------------------------------- 57124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_size_t 57224943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ReadMemory (nub_addr_t addr, nub_size_t size, void *buf) 57324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 57424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We need to remove any current software traps (enabled software 57524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // breakpoints) that we may have placed in our tasks memory. 57624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 57724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // First just read the memory as is 57824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t bytes_read = m_task.ReadMemory(addr, size, buf); 57924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 58024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Then place any opcodes that fall into this range back into the buffer 58124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // before we return this to callers. 58224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_read > 0) 583ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.RemoveTrapsFromBuffer (addr, bytes_read, buf); 58424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return bytes_read; 58524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 58624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 58724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//---------------------------------------------------------------------- 58824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// WriteMemory from the MachProcess level will always write memory around 58924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// any software breakpoints. Any software breakpoints will have their 59024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// opcodes modified if they are enabled. Any memory that doesn't overlap 59124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// with software breakpoints will be written to. If you wish to write to 59224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// inferior memory without this interference, then write to the MachTask 59324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// (m_task.WriteMemory()) as that version will always modify inferior 59424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// memory. 59524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner//---------------------------------------------------------------------- 59624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_size_t 59724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf) 59824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 59924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We need to write any data that would go where any current software traps 60024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // (enabled software breakpoints) any software traps (breakpoints) that we 60124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // may have placed in our tasks memory. 60224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 603ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton std::vector<DNBBreakpoint *> bps; 604ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 605ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton const size_t num_bps = m_breakpoints.FindBreakpointsThatOverlapRange(addr, size, bps); 606ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (num_bps == 0) 60724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_task.WriteMemory(addr, size, buf); 60824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 60924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t bytes_written = 0; 61024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_addr_t intersect_addr; 61124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t intersect_size; 61224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t opcode_offset; 61324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const uint8_t *ubuf = (const uint8_t *)buf; 614ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 615ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton for (size_t i=0; i<num_bps; ++i) 61624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 617ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *bp = bps[i]; 61824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 619ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset); 620ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton assert(intersects); 62124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner assert(addr <= intersect_addr && intersect_addr < addr + size); 62224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size); 62324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner assert(opcode_offset + intersect_size <= bp->ByteSize()); 624ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 62524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Check for bytes before this breakpoint 62624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const nub_addr_t curr_addr = addr + bytes_written; 62724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (intersect_addr > curr_addr) 62824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 62924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // There are some bytes before this breakpoint that we need to 63024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // just write to memory 63124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t curr_size = intersect_addr - curr_addr; 63224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_size_t curr_bytes_written = m_task.WriteMemory(curr_addr, curr_size, ubuf + bytes_written); 63324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_written += curr_bytes_written; 63424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (curr_bytes_written != curr_size) 63524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 63624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We weren't able to write all of the requested bytes, we 63724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // are done looping and will return the number of bytes that 63824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // we have written so far. 63924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 64024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 64124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 642ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 64324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Now write any bytes that would cover up any software breakpoints 64424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // directly into the breakpoint opcode buffer 64524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::memcpy(bp->SavedOpcodeBytes() + opcode_offset, ubuf + bytes_written, intersect_size); 64624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_written += intersect_size; 64724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 648ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 64924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Write any remaining bytes after the last breakpoint if we have any left 65024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_written < size) 65124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_written += m_task.WriteMemory(addr + bytes_written, size - bytes_written, ubuf + bytes_written); 652ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 65324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return bytes_written; 65424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 65524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 65624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 657c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg ClaytonMachProcess::ReplyToAllExceptions () 65824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 65924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex); 66024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_exception_messages.empty() == false) 66124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 66224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachException::Message::iterator pos; 66324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachException::Message::iterator begin = m_exception_messages.begin(); 66424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachException::Message::iterator end = m_exception_messages.end(); 66524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (pos = begin; pos != end; ++pos) 66624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 6670e8147bd867e4cdaae9400f56d02c7aacd40a9b3Greg Clayton DNBLogThreadedIf(LOG_EXCEPTIONS, "Replying to exception %u...", (uint32_t)std::distance(begin, pos)); 66824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int thread_reply_signal = 0; 66924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 67044eb9fb021023027159df55f91c3e95384088970Jason Molenda nub_thread_t tid = m_thread_list.GetThreadIDByMachPortNumber (pos->state.thread_port); 67144eb9fb021023027159df55f91c3e95384088970Jason Molenda const DNBThreadResumeAction *action = NULL; 67244eb9fb021023027159df55f91c3e95384088970Jason Molenda if (tid != INVALID_NUB_THREAD) 67344eb9fb021023027159df55f91c3e95384088970Jason Molenda { 67444eb9fb021023027159df55f91c3e95384088970Jason Molenda action = m_thread_actions.GetActionForThread (tid, false); 67544eb9fb021023027159df55f91c3e95384088970Jason Molenda } 67624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 67724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (action) 67824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 67924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner thread_reply_signal = action->signal; 68024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (thread_reply_signal) 68144eb9fb021023027159df55f91c3e95384088970Jason Molenda m_thread_actions.SetSignalHandledForThread (tid); 68224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 68324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 68435c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err (pos->Reply(this, thread_reply_signal)); 68524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) 68635c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.LogThreadedIfError("Error replying to exception"); 68724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 68824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 68924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Erase all exception message as we should have used and replied 69024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // to them all already. 69124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages.clear(); 69224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 69324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 69424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 695c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg ClaytonMachProcess::PrivateResume () 69624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 69724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex); 69824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 699c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton ReplyToAllExceptions (); 70024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// bool stepOverBreakInstruction = step; 70124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 70224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the thread prepare to resume and see if any threads want us to 70324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // step over a breakpoint instruction (ProcessWillResume will modify 70424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // the value of stepOverBreakInstruction). 705c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton m_thread_list.ProcessWillResume (this, m_thread_actions); 70624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 70724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Set our state accordingly 708c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton if (m_thread_actions.NumActionsWithState(eStateStepping)) 70924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateStepping); 71024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 71124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateRunning); 71224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 71324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Now resume our task. 71435c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton m_task.Resume(); 71524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 71624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 717ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonDNBBreakpoint * 718ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length, bool hardware) 71924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 720ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = 0x%8.8llx, length = %llu, hardware = %i)", (uint64_t)addr, (uint64_t)length, hardware); 72124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 722ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr); 723ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (bp) 724ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton bp->Retain(); 725ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton else 726ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton bp = m_breakpoints.Add(addr, length, hardware); 727ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 728ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (EnableBreakpoint(addr)) 72924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 730ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = 0x%8.8llx, length = %llu) => %p", (uint64_t)addr, (uint64_t)length, bp); 731ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return bp; 73224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 733ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton else if (bp->Release() == 0) 73424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 735ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.Remove(addr); 73624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 73724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We failed to enable the breakpoint 738ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return NULL; 73924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 74024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 741ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonDNBBreakpoint * 742ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length, uint32_t watch_flags, bool hardware) 74324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 744ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %llu, flags = 0x%8.8x, hardware = %i)", (uint64_t)addr, (uint64_t)length, watch_flags, hardware); 74524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 746ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr); 747ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // since the Z packets only send an address, we can only have one watchpoint at 748ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // an address. If there is already one, we must refuse to create another watchpoint 749ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (wp) 750ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return NULL; 751ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 752ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton wp = m_watchpoints.Add(addr, length, hardware); 753ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton wp->SetIsWatchpoint(watch_flags); 75424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 755ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (EnableWatchpoint(addr)) 75624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 757ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %llu) => %p", (uint64_t)addr, (uint64_t)length, wp); 758ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return wp; 75924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 76024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 76124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 762ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = 0x%8.8llx, length = %llu) => FAILED", (uint64_t)addr, (uint64_t)length); 763ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_watchpoints.Remove(addr); 76424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 76524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We failed to enable the watchpoint 766ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return NULL; 76724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 76824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 769ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Claytonvoid 770ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::DisableAllBreakpoints (bool remove) 77124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 77224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::%s (remove = %d )", __FUNCTION__, remove); 773ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 774ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.DisableAllBreakpoints (this); 775ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 776ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove) 777ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.RemoveDisabled(); 77824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 77924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 780ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Claytonvoid 78124943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::DisableAllWatchpoints(bool remove) 78224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 78324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s (remove = %d )", __FUNCTION__, remove); 784ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 785ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_watchpoints.DisableAllWatchpoints(this); 786ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 787ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove) 788ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_watchpoints.RemoveDisabled(); 78924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 79024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 79124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 792ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::DisableBreakpoint(nub_addr_t addr, bool remove) 79324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 794ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr); 79524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp) 79624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 7974d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // After "exec" we might end up with a bunch of breakpoints that were disabled 7984d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // manually, just ignore them 7994d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (!bp->IsEnabled()) 800ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton { 801ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // Breakpoint might have been disabled by an exec 802ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove && bp->Release() == 0) 803ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton { 804ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_thread_list.NotifyBreakpointChanged(bp); 805ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.Remove(addr); 806ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton } 807ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return true; 808ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton } 809ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 810ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // We have multiple references to this breakpoint, decrement the ref count 811ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // and if it isn't zero, then return true; 812ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove && bp->Release() > 0) 8134d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton return true; 8144d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton 815ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE, "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d )", (uint64_t)addr, remove); 81624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 81724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp->IsHardware()) 81824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 8193b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint (bp); 82024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 82124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (hw_disable_result == true) 82224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 82324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bp->SetEnabled(false); 82424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the thread list know that a breakpoint has been modified 82524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (remove) 82624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 8273b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.NotifyBreakpointChanged(bp); 828ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.Remove(addr); 82924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 830ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) (hardware) => success", (uint64_t)addr, remove); 83124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 83224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 83324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 83424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return false; 83524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 83624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 83724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const nub_size_t break_op_size = bp->ByteSize(); 83824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner assert (break_op_size > 0); 83920d338fad87eba91de65aa9bec76e01c04472848Greg Clayton const uint8_t * const break_op = DNBArchProtocol::GetBreakpointOpcode (bp->ByteSize()); 84024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (break_op_size > 0) 84124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 84224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear a software breakoint instruction 84324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner uint8_t curr_break_op[break_op_size]; 84424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bool break_op_found = false; 84524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 84624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Read the breakpoint opcode 84724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.ReadMemory(addr, break_op_size, curr_break_op) == break_op_size) 84824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 84924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bool verify = false; 85024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp->IsEnabled()) 85124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 85224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Make sure we have the a breakpoint opcode exists at this address 85324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (memcmp(curr_break_op, break_op, break_op_size) == 0) 85424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 85524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break_op_found = true; 85624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We found a valid breakpoint opcode at this address, now restore 85724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // the saved opcode. 85824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.WriteMemory(addr, break_op_size, bp->SavedOpcodeBytes()) == break_op_size) 85924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 86024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner verify = true; 86124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 86224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 86324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 864ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) memory write failed when restoring original opcode", addr, remove); 86524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 86624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 86724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 86824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 869ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogWarning("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) expected a breakpoint opcode but didn't find one.", addr, remove); 87024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Set verify to true and so we can check if the original opcode has already been restored 87124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner verify = true; 87224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 87324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 87424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 87524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 876ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE, "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) is not enabled", addr, remove); 87724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Set verify to true and so we can check if the original opcode is there 87824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner verify = true; 87924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 88024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 88124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (verify) 88224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 88324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner uint8_t verify_opcode[break_op_size]; 88424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Verify that our original opcode made it back to the inferior 88524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.ReadMemory(addr, break_op_size, verify_opcode) == break_op_size) 88624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 88724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // compare the memory we just read with the original opcode 88824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (memcmp(bp->SavedOpcodeBytes(), verify_opcode, break_op_size) == 0) 88924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 89024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // SUCCESS 89124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bp->SetEnabled(false); 89224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the thread list know that a breakpoint has been modified 893ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove && bp->Release() == 0) 89424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 8953b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.NotifyBreakpointChanged(bp); 896ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_breakpoints.Remove(addr); 89724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 898ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) => success", (uint64_t)addr, remove); 89924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 90024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 90124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 90224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 90324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (break_op_found) 904ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) : failed to restore original opcode", (uint64_t)addr, remove); 90524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 906ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) : opcode changed", (uint64_t)addr, remove); 90724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 90824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 90924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 91024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 91124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable breakpoint 0x%8.8llx", (uint64_t)addr); 91224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 91324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 91424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 91524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 91624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 91724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogWarning("MachProcess::DisableBreakpoint: unable to read memory at 0x%8.8llx", (uint64_t)addr); 91824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 91924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 92024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 92124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 92224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 923ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d ) invalid breakpoint address", (uint64_t)addr, remove); 92424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 92524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return false; 92624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 92724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 92824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 929ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::DisableWatchpoint(nub_addr_t addr, bool remove) 93024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 931ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s(addr = 0x%8.8llx, remove = %d)", __FUNCTION__, (uint64_t)addr, remove); 932ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr); 93324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (wp) 93424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 935ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton // If we have multiple references to a watchpoint, removing the watchpoint shouldn't clear it 936ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton if (remove && wp->Release() > 0) 937ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton return true; 938ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton 93924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_addr_t addr = wp->Address(); 940ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = %d )", (uint64_t)addr, remove); 94124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 94224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (wp->IsHardware()) 94324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 9443b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint (wp); 94524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 94624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (hw_disable_result == true) 94724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 94824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner wp->SetEnabled(false); 94924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (remove) 950ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton m_watchpoints.Remove(addr); 951ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::Disablewatchpoint ( addr = 0x%8.8llx, remove = %d ) (hardware) => success", (uint64_t)addr, remove); 95224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 95324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 95424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 95524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 95624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // TODO: clear software watchpoints if we implement them 95724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 95824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 95924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 960ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = %d ) invalid watchpoint ID", (uint64_t)addr, remove); 96124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 96224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return false; 96324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 96424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 96524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 9667cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny Chenuint32_t 9677cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny ChenMachProcess::GetNumSupportedHardwareWatchpoints () const 9687cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny Chen{ 9697cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny Chen return m_thread_list.NumSupportedHardwareWatchpoints(); 9707cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny Chen} 9717cbdcfb0cefcfd877b507ff2d83e51a1bde3fcc7Johnny Chen 97224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 973ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::EnableBreakpoint(nub_addr_t addr) 97424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 975ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::EnableBreakpoint ( addr = 0x%8.8llx )", (uint64_t)addr); 976ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr); 97724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp) 97824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 97924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp->IsEnabled()) 98024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 981ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogWarning("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): breakpoint already enabled.", (uint64_t)addr); 98224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 98324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 98424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 98524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 98624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp->HardwarePreferred()) 98724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 9883b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp)); 98924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bp->IsHardware()) 99024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 99124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bp->SetEnabled(true); 99224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 99324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 99424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 99524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 99624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const nub_size_t break_op_size = bp->ByteSize(); 99724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner assert (break_op_size != 0); 99820d338fad87eba91de65aa9bec76e01c04472848Greg Clayton const uint8_t * const break_op = DNBArchProtocol::GetBreakpointOpcode (break_op_size); 99924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (break_op_size > 0) 100024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 100124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Save the original opcode by reading it 100224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.ReadMemory(addr, break_op_size, bp->SavedOpcodeBytes()) == break_op_size) 100324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 100424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Write a software breakpoint in place of the original opcode 100524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.WriteMemory(addr, break_op_size, break_op) == break_op_size) 100624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 100724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner uint8_t verify_break_op[4]; 100824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_task.ReadMemory(addr, break_op_size, verify_break_op) == break_op_size) 100924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 101024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (memcmp(break_op, verify_break_op, break_op_size) == 0) 101124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 101224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bp->SetEnabled(true); 101324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the thread list know that a breakpoint has been modified 10143b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.NotifyBreakpointChanged(bp); 1015ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ) : SUCCESS.", (uint64_t)addr); 101624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 101724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 101824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 101924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1020ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): breakpoint opcode verification failed.", (uint64_t)addr); 102124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 102224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 102324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 102424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1025ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): unable to read memory to verify breakpoint opcode.", (uint64_t)addr); 102624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 102724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 102824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 102924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1030ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): unable to write breakpoint opcode to memory.", (uint64_t)addr); 103124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 103224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 103324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 103424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1035ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): unable to read memory at breakpoint address.", (uint64_t)addr); 103624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 103724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 103824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 103924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1040ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ) no software breakpoint opcode for current architecture.", (uint64_t)addr); 104124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 104224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 104324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 104424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return false; 104524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 104624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 104724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerbool 1048ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg ClaytonMachProcess::EnableWatchpoint(nub_addr_t addr) 104924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1050ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::EnableWatchpoint(addr = 0x%8.8llx)", (uint64_t)addr); 1051ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr); 105224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (wp) 105324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 105424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_addr_t addr = wp->Address(); 105524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (wp->IsEnabled()) 105624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1057ac94caa68a4a5fa4bd939d7656a6a12d8fc06a33Greg Clayton DNBLogWarning("MachProcess::EnableWatchpoint(addr = 0x%8.8llx): watchpoint already enabled.", (uint64_t)addr); 105824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 105924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 106024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 106124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 106224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Currently only try and set hardware watchpoints. 10633b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp)); 106424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (wp->IsHardware()) 106524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 106624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner wp->SetEnabled(true); 106724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return true; 106824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 106924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // TODO: Add software watchpoints by doing page protection tricks. 107024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 107124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 107224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return false; 107324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 107424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 107524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Called by the exception thread when an exception has been received from 107624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// our process. The exception message is completely filled and the exception 107724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// data has already been copied. 107824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 107924943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ExceptionMessageReceived (const MachException::Message& exceptionMessage) 108024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 108124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex); 108224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 108324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_exception_messages.empty()) 108424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_task.Suspend(); 108524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 108624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_EXCEPTIONS, "MachProcess::ExceptionMessageReceived ( )"); 108724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 108824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Use a locker to automatically unlock our mutex in case of exceptions 108924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Add the exception to our internal exception stack 109024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages.push_back(exceptionMessage); 109124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 109224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 109324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 109424943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ExceptionMessageBundleComplete() 109524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 109624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We have a complete bundle of exceptions for our child process. 109724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER (locker, m_exception_messages_mutex); 1098851e30ec6a1b1d2c154bb7d69ed0d05b5fd14705Greg Clayton DNBLogThreadedIf(LOG_EXCEPTIONS, "%s: %llu exception messages.", __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size()); 109924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (!m_exception_messages.empty()) 110024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 11014d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_did_exec = false; 11024d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // First check for any SIGTRAP and make sure we didn't exec 11034d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton const task_t task = m_task.TaskPort(); 11044d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton size_t i; 11054d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_pid != 0) 11064d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11074d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton for (i=0; i<m_exception_messages.size(); ++i) 11084d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11094d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_exception_messages[i].state.task_port == task) 11104d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11114d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton const int signo = m_exception_messages[i].state.SoftSignal(); 11124d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (signo == SIGTRAP) 11134d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11144d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // SIGTRAP could mean that we exec'ed. We need to check the 11154d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // dyld all_image_infos.infoArray to see if it is NULL and if 11164d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton // so, say that we exec'ed. 11174d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton const nub_addr_t aii_addr = GetDYLDAllImageInfosAddress(); 11184d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (aii_addr != INVALID_NUB_ADDRESS) 11194d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11204d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton const nub_addr_t info_array_count_addr = aii_addr + 4; 11214d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton uint32_t info_array_count = 0; 11224d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_task.ReadMemory(info_array_count_addr, 4, &info_array_count) == 4) 11234d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11244d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton DNBLog ("info_array_count is 0x%x", info_array_count); 11254d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (info_array_count == 0) 11264d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_did_exec = true; 11274d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11284d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton else 11294d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11304d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton DNBLog ("error: failed to read all_image_infos.infoArrayCount from 0x%8.8llx", info_array_count_addr); 11314d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11324d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11334d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton break; 11344d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11354d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11364d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11374d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton 11384d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_did_exec) 11394d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11404d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton cpu_type_t process_cpu_type = MachProcess::GetCPUTypeForLocalProcess (m_pid); 11414d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton if (m_cpu_type != process_cpu_type) 11424d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton { 11434d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton DNBLog ("arch changed from 0x%8.8x to 0x%8.8x", m_cpu_type, process_cpu_type); 11444d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_cpu_type = process_cpu_type; 11454d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton DNBArchProtocol::SetArchitecture (process_cpu_type); 11464d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11474d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_thread_list.Clear(); 11484d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton m_breakpoints.DisableAll(); 11494d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11504d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton } 11514d4ff9e8f7746ba1b1d597512b7cb711350c0206Greg Clayton 115224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let all threads recover from stopping and do any clean up based 115324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // on the previous thread state (if any). 11543b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.ProcessDidStop(this); 115524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 115624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let each thread know of any exceptions 115724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (i=0; i<m_exception_messages.size(); ++i) 115824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 115924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the thread list figure use the MachProcess to forward all exceptions 116024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // on down to each thread. 116124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_exception_messages[i].state.task_port == task) 11623b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.NotifyException(m_exception_messages[i].state); 116324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (DNBLogCheckLogBit(LOG_EXCEPTIONS)) 116424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_exception_messages[i].Dump(); 116524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 116624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 116724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (DNBLogCheckLogBit(LOG_THREAD)) 11683b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton m_thread_list.Dump(); 116924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 117024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bool step_more = false; 11713b2c41c9d12bafdad87cc271fadd1f816081b9a8Greg Clayton if (m_thread_list.ShouldStop(step_more)) 117224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 117324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Wait for the eEventProcessRunningStateChanged event to be reset 117424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // before changing state to stopped to avoid race condition with 117524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // very fast start/stops 117624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner struct timespec timeout; 117724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //DNBTimer::OffsetTimeOfDay(&timeout, 0, 250 * 1000); // Wait for 250 ms 117824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBTimer::OffsetTimeOfDay(&timeout, 1, 0); // Wait for 250 ms 117924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.WaitForEventsToReset(eEventProcessRunningStateChanged, &timeout); 118024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState(eStateStopped); 118124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 118224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 118324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 118424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Resume without checking our current state. 1185c71899ef308e6134d1b0ca5f30cbc64414855e1aGreg Clayton PrivateResume (); 118624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 118724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 118824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 118924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1190851e30ec6a1b1d2c154bb7d69ed0d05b5fd14705Greg Clayton DNBLogThreadedIf(LOG_EXCEPTIONS, "%s empty exception messages bundle (%llu exceptions).", __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size()); 119124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 119224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 119324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 119424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_size_t 119524943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::CopyImageInfos ( struct DNBExecutableImageInfo **image_infos, bool only_changed) 119624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 119724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_image_infos_callback != NULL) 119824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_image_infos_callback(ProcessID(), image_infos, only_changed, m_image_infos_baton); 119924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return 0; 120024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 120124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 120224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 120324943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::SharedLibrariesUpdated ( ) 120424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 120524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner uint32_t event_bits = eEventSharedLibsStateChange; 120624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Set the shared library event bit to let clients know of shared library 120724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // changes 120824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.SetEvents(event_bits); 120924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Wait for the event bit to reset if a reset ACK is requested 121024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.WaitForResetAck(event_bits); 121124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 121224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 121324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 121424943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::AppendSTDOUT (char* s, size_t len) 121524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1216851e30ec6a1b1d2c154bb7d69ed0d05b5fd14705Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (<%llu> %s) ...", __FUNCTION__, (uint64_t)len, s); 121724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER (locker, m_stdio_mutex); 121824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdout_data.append(s, len); 121924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.SetEvents(eEventStdioAvailable); 122024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 122124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Wait for the event bit to reset if a reset ACK is requested 122224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_events.WaitForResetAck(eEventStdioAvailable); 122324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 122424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 122524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnersize_t 122624943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetAvailableSTDOUT (char *buf, size_t buf_size) 122724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 1228851e30ec6a1b1d2c154bb7d69ed0d05b5fd14705Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__, buf, (uint64_t)buf_size); 122924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PTHREAD_MUTEX_LOCKER (locker, m_stdio_mutex); 123024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t bytes_available = m_stdout_data.size(); 123124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_available > 0) 123224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 123324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_available > buf_size) 123424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 123524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner memcpy(buf, m_stdout_data.data(), buf_size); 123624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdout_data.erase(0, buf_size); 123724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_available = buf_size; 123824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 123924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 124024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 124124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner memcpy(buf, m_stdout_data.data(), bytes_available); 124224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_stdout_data.clear(); 124324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 124424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 124524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return bytes_available; 124624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 124724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 124824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_addr_t 124924943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetDYLDAllImageInfosAddress () 125024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 125135c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err; 125235c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton return m_task.GetDYLDAllImageInfosAddress(err); 125324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 125424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 125524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnersize_t 125624943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::GetAvailableSTDERR (char *buf, size_t buf_size) 125724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 125824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return 0; 125924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 126024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 126124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid * 126224943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::STDIOThread(void *arg) 126324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 126424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachProcess *proc = (MachProcess*) arg; 126524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( arg = %p ) thread starting...", __FUNCTION__, arg); 126624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 126724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We start use a base and more options so we can control if we 126824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // are currently using a timeout on the mach_msg. We do this to get a 126924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // bunch of related exceptions on our exception port so we can process 127024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // then together. When we have multiple threads, we can get an exception 127124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // per thread and they will come in consecutively. The main thread loop 127224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // will start by calling mach_msg to without having the MACH_RCV_TIMEOUT 127324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // flag set in the options, so we will wait forever for an exception on 127424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // our exception port. After we get one exception, we then will use the 127524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // MACH_RCV_TIMEOUT option with a zero timeout to grab all other current 127624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // exceptions for our process. After we have received the last pending 127724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // exception, we will get a timeout which enables us to then notify 127824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // our main thread that we have an exception bundle avaiable. We then wait 127924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // for the main thread to tell this exception thread to start trying to get 128024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // exceptions messages again and we start again with a mach_msg read with 128124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // infinite timeout. 128224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError err; 128324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int stdout_fd = proc->GetStdoutFileDescriptor(); 128424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int stderr_fd = proc->GetStderrFileDescriptor(); 128524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stdout_fd == stderr_fd) 128624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stderr_fd = -1; 128724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 128824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner while (stdout_fd >= 0 || stderr_fd >= 0) 128924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 129024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::pthread_testcancel (); 129124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 129224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner fd_set read_fds; 129324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner FD_ZERO (&read_fds); 129424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stdout_fd >= 0) 129524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner FD_SET (stdout_fd, &read_fds); 129624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stderr_fd >= 0) 129724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner FD_SET (stderr_fd, &read_fds); 129824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int nfds = std::max<int>(stdout_fd, stderr_fd) + 1; 129924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 130024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int num_set_fds = select (nfds, &read_fds, NULL, NULL, NULL); 130124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds); 130224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 130324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (num_set_fds < 0) 130424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 130524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int select_errno = errno; 130624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (DNBLogCheckLogBit(LOG_PROCESS)) 130724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 130824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.SetError (select_errno, DNBError::POSIX); 130924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.LogThreadedIfError("select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds); 131024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 131124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 131224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner switch (select_errno) 131324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 131424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case EAGAIN: // The kernel was (perhaps temporarily) unable to allocate the requested number of file descriptors, or we have non-blocking IO 131524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 131624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case EBADF: // One of the descriptor sets specified an invalid descriptor. 131724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 131824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 131924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case EINTR: // A signal was delivered before the time limit expired and before any of the selected events occurred. 132024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case EINVAL: // The specified time limit is invalid. One of its components is negative or too large. 132124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner default: // Other unknown error 132224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 132324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 132424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 132524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (num_set_fds == 0) 132624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 132724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 132824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 132924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 133024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char s[1024]; 133124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner s[sizeof(s)-1] = '\0'; // Ensure we have NULL termination 133224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int bytes_read = 0; 133324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stdout_fd >= 0 && FD_ISSET (stdout_fd, &read_fds)) 133424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 133524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner do 133624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 133724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_read = ::read (stdout_fd, s, sizeof(s)-1); 133824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_read < 0) 133924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 134024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int read_errno = errno; 134124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "read (stdout_fd, ) => %d errno: %d (%s)", bytes_read, read_errno, strerror(read_errno)); 134224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 134324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (bytes_read == 0) 134424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 134524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // EOF... 134624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "read (stdout_fd, ) => %d (reached EOF for child STDOUT)", bytes_read); 134724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdout_fd = -1; 134824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 134924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (bytes_read > 0) 135024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 135124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner proc->AppendSTDOUT(s, bytes_read); 135224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 135324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 135424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } while (bytes_read > 0); 135524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 135624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 135724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stderr_fd >= 0 && FD_ISSET (stderr_fd, &read_fds)) 135824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 135924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner do 136024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 136124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner bytes_read = ::read (stderr_fd, s, sizeof(s)-1); 136224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bytes_read < 0) 136324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 136424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int read_errno = errno; 136524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "read (stderr_fd, ) => %d errno: %d (%s)", bytes_read, read_errno, strerror(read_errno)); 136624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 136724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (bytes_read == 0) 136824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 136924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // EOF... 137024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "read (stderr_fd, ) => %d (reached EOF for child STDERR)", bytes_read); 137124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stderr_fd = -1; 137224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 137324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (bytes_read > 0) 137424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 137524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner proc->AppendSTDOUT(s, bytes_read); 137624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 137724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 137824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } while (bytes_read > 0); 137924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 138024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 138124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 138224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%p): thread exiting...", __FUNCTION__, arg); 138324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 138424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 138524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1386fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1387fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ongvoid 1388fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming OngMachProcess::SignalAsyncProfileData (const char *info) 1389fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong{ 1390fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%s) ...", __FUNCTION__, info); 1391fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong PTHREAD_MUTEX_LOCKER (locker, m_profile_data_mutex); 1392f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong m_profile_data.push_back(info); 1393fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_events.SetEvents(eEventProfileDataAvailable); 1394fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1395fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong // Wait for the event bit to reset if a reset ACK is requested 1396fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong m_events.WaitForResetAck(eEventProfileDataAvailable); 1397fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong} 1398fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1399fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1400fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ongsize_t 1401fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming OngMachProcess::GetAsyncProfileData (char *buf, size_t buf_size) 1402fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong{ 1403fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__, buf, (uint64_t)buf_size); 1404fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong PTHREAD_MUTEX_LOCKER (locker, m_profile_data_mutex); 1405f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong if (m_profile_data.empty()) 1406f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong return 0; 1407f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong 1408f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong size_t bytes_available = m_profile_data.front().size(); 1409fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong if (bytes_available > 0) 1410fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1411fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong if (bytes_available > buf_size) 1412fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1413f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong memcpy(buf, m_profile_data.front().data(), buf_size); 1414f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong m_profile_data.front().erase(0, buf_size); 1415fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong bytes_available = buf_size; 1416fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1417fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong else 1418fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1419f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong memcpy(buf, m_profile_data.front().data(), bytes_available); 1420f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong m_profile_data.erase(m_profile_data.begin()); 1421fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1422fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1423fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong return bytes_available; 1424fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong} 1425fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1426fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1427fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ongvoid * 1428fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming OngMachProcess::ProfileThread(void *arg) 1429fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong{ 1430fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong MachProcess *proc = (MachProcess*) arg; 1431fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( arg = %p ) thread starting...", __FUNCTION__, arg); 1432fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1433fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong while (proc->IsProfilingEnabled()) 1434fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1435fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong nub_state_t state = proc->GetState(); 1436fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong if (state == eStateRunning) 1437fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1438cec43ab7f30085ac7f65a26a58b956a69e363a3bHan Ming Ong std::string data = proc->Task().GetProfileData(proc->GetProfileScanType()); 1439f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong if (!data.empty()) 1440fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1441f14269add7f6fb84da7ccfd866f8e9f7e81068beHan Ming Ong proc->SignalAsyncProfileData(data.c_str()); 1442fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1443fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1444fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong else if ((state == eStateUnloaded) || (state == eStateDetached) || (state == eStateUnloaded)) 1445fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong { 1446fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong // Done. Get out of this thread. 1447fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong break; 1448fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1449fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1450fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong // A simple way to set up the profile interval. We can also use select() or dispatch timer source if necessary. 1451fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong usleep(proc->ProfileInterval()); 1452fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong } 1453fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong return NULL; 1454fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong} 1455fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 1456fb9cee64303d36d6fe5d87e63dd8701d1ddb70a9Han Ming Ong 145724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 145824943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::AttachForDebug (pid_t pid, char *err_str, size_t err_len) 145924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 146024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear out and clean up from any current state 146124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 146224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pid != 0) 146324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 146435c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton DNBError err; 146524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Make sure the process exists... 146624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (::getpgid (pid) < 0) 146724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 146835c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.SetErrorToErrno(); 146935c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton const char *err_cstr = err.AsString(); 147024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::snprintf (err_str, err_len, "%s", err_cstr ? err_cstr : "No such process"); 147124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 147224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 147324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 147424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState(eStateAttaching); 147524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = pid; 147624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let ourselves know we are going to be using SBS if the correct flag bit is set... 14779a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 147824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (IsSBProcess(pid)) 147924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags |= eMachProcessFlagsUsingSBS; 148024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 148135c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton if (!m_task.StartExceptionThread(err)) 148224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 148335c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton const char *err_cstr = err.AsString(); 148424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::snprintf (err_str, err_len, "%s", err_cstr ? err_cstr : "unable to start the exception thread"); 148524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid); 148624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = INVALID_NUB_PROCESS; 148724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 148824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 148924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 149024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner errno = 0; 149135c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton if (::ptrace (PT_ATTACHEXC, pid, 0, 0)) 149235c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.SetError(errno); 149324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 149435c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton err.Clear(); 149524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 149635c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton if (err.Success()) 149724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 149824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags |= eMachProcessFlagsAttached; 149924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Sleep a bit to let the exception get received and set our process status 150024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // to stopped. 150124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::usleep(250000); 150224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid); 150324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_pid; 150424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 150524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 150624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 150735c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton ::snprintf (err_str, err_len, "%s", err.AsString()); 150824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid); 150924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 151024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 151124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 151224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 151324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 151424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Do the process specific setup for attach. If this returns NULL, then there's no 151524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// platform specific stuff to be done to wait for the attach. If you get non-null, 151624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// pass that token to the CheckForProcess method, and then to CleanupAfterAttach. 151724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 151824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Call PrepareForAttach before attaching to a process that has not yet launched 151924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// This returns a token that can be passed to CheckForProcess, and to CleanupAfterAttach. 152024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// You should call CleanupAfterAttach to free the token, and do whatever other 152124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// cleanup seems good. 152224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 152324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerconst void * 152424943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::PrepareForAttach (const char *path, nub_launch_flavor_t launch_flavor, bool waitfor, DNBError &err_str) 152524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 15269a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 152724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Tell SpringBoard to halt the next launch of this application on startup. 152824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 152924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (!waitfor) 153024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 153124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 153224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *app_ext = strstr(path, ".app"); 1533aeabc5e251105512ea7539b2f62ad3edd485d0dcGreg Clayton const bool is_app = app_ext != NULL && (app_ext[4] == '\0' || app_ext[4] == '/'); 1534aeabc5e251105512ea7539b2f62ad3edd485d0dcGreg Clayton if (!is_app) 153524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 15363e4238d47a6d1a3106f357d2e7b495870721c7aeGreg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::PrepareForAttach(): path '%s' doesn't contain .app, we can't tell springboard to wait for launch...", path); 153724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 153824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 153924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 154024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (launch_flavor != eLaunchFlavorSpringBoard 154124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner && launch_flavor != eLaunchFlavorDefault) 154224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 154324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 154424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner std::string app_bundle_path(path, app_ext + strlen(".app")); 154524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 154624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFStringRef bundleIDCFStr = CopyBundleIDForPath (app_bundle_path.c_str (), err_str); 154724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner std::string bundleIDStr; 154824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString::UTF8(bundleIDCFStr, bundleIDStr); 154924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "CopyBundleIDForPath (%s, err_str) returned @\"%s\"", app_bundle_path.c_str (), bundleIDStr.c_str()); 155024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 155124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bundleIDCFStr == NULL) 155224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 155324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 155424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 155524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 155624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationLaunchError sbs_error = 0; 155724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 155824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *stdout_err = "/dev/null"; 155924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString stdio_path; 156024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.SetFileSystemRepresentation (stdout_err); 156124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 156224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "SBSLaunchApplicationForDebugging ( @\"%s\" , NULL, NULL, NULL, @\"%s\", @\"%s\", SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger )", bundleIDStr.c_str(), stdout_err, stdout_err); 156324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr, 156424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner (CFURLRef)NULL, // openURL 156524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, // launch_argv.get(), 156624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, // launch_envp.get(), // CFDictionaryRef environment 156724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.get(), 156824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.get(), 156924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger); 157024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 157124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (sbs_error != SBSApplicationLaunchErrorSuccess) 157224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 157324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetError(sbs_error, DNBError::SpringBoard); 157424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 157524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 157624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 157724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "Successfully set DebugOnNextLaunch."); 157824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return bundleIDCFStr; 157924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner# else 158024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 158124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 158224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 158324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 158424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Pass in the token you got from PrepareForAttach. If there is a process 158524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// for that token, then the pid will be returned, otherwise INVALID_NUB_PROCESS 158624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// will be returned. 158724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 158824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnernub_process_t 158924943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::CheckForProcess (const void *attach_token) 159024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 159124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (attach_token == NULL) 159224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 159324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 15949a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 159524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFStringRef bundleIDCFStr = (CFStringRef) attach_token; 159624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Boolean got_it; 159724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_process_t attach_pid; 159824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner got_it = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &attach_pid); 159924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (got_it) 160024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return attach_pid; 160124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 160224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 160324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 160424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 160524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 160624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 160724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Call this to clean up after you have either attached or given up on the attach. 160824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// Pass true for success if you have attached, false if you have not. 160924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// The token will also be freed at this point, so you can't use it after calling 161024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// this method. 161124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 161224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnervoid 161324943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::CleanupAfterAttach (const void *attach_token, bool success, DNBError &err_str) 161424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 16159a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 161624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (attach_token == NULL) 161724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return; 161824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 161924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Tell SpringBoard to cancel the debug on next launch of this application 162024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // if we failed to attach 162124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (!success) 162224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 162324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationLaunchError sbs_error = 0; 162424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFStringRef bundleIDCFStr = (CFStringRef) attach_token; 162524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 162624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr, 162724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner (CFURLRef)NULL, 162824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, 162924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, 163024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, 163124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner NULL, 163224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationCancelDebugOnNextLaunch); 163324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 163424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (sbs_error != SBSApplicationLaunchErrorSuccess) 163524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 163624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetError(sbs_error, DNBError::SpringBoard); 163724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return; 163824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 163924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 164024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 164124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFRelease((CFStringRef) attach_token); 164224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 164324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 164424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 164524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 164624943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::LaunchForDebug 164724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner( 164824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *path, 164924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *argv[], 165024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *envp[], 165172e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *working_directory, // NULL => dont' change, non-NULL => set working directory for inferior to this 165272e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stdin_path, 165372e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stdout_path, 165472e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stderr_path, 1655bd666017403e102e0ca435d6da585ff979f83598Caroline Tice bool no_stdio, 165624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_launch_flavor_t launch_flavor, 1657452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton int disable_aslr, 165824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError &launch_err 165924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner) 166024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 166124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear out and clean up from any current state 166224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 166324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1664452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "%s( path = '%s', argv = %p, envp = %p, launch_flavor = %u, disable_aslr = %d )", __FUNCTION__, path, argv, envp, launch_flavor, disable_aslr); 166524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 166624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Fork a child process for debugging 166724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState(eStateLaunching); 166824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 166924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner switch (launch_flavor) 167024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 167124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case eLaunchFlavorForkExec: 167224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = MachProcess::ForkChildForPTraceDebugging (path, argv, envp, this, launch_err); 167324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 167424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 167533a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen#ifdef WITH_SPRINGBOARD 167633a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen 167733a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen case eLaunchFlavorSpringBoard: 167833a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen { 1679473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda // .../whatever.app/whatever ? 1680473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda // Or .../com.apple.whatever.app/whatever -- be careful of ".app" in "com.apple.whatever" here 1681473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda const char *app_ext = strstr (path, ".app/"); 1682473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda if (app_ext == NULL) 1683473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda { 1684473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda // .../whatever.app ? 1685473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda int len = strlen (path); 1686473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda if (len > 5) 1687473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda { 1688473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda if (strcmp (path + len - 4, ".app") == 0) 1689473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda { 1690473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda app_ext = path + len - 4; 1691473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda } 1692473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda } 1693473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda } 1694473ff991a3295666eddf89415f6c38ac4afad230Jason Molenda if (app_ext) 169533a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen { 169633a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen std::string app_bundle_path(path, app_ext + strlen(".app")); 169733a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen if (SBLaunchForDebug (app_bundle_path.c_str(), argv, envp, no_stdio, launch_err) != 0) 169833a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen return m_pid; // A successful SBLaunchForDebug() returns and assigns a non-zero m_pid. 1699d9899e0ea327e5a57b7bb8b0f814d695e86f1082Greg Clayton else 1700d9899e0ea327e5a57b7bb8b0f814d695e86f1082Greg Clayton break; // We tried a springboard launch, but didn't succeed lets get out 170133a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen } 170233a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen } 170333a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen // In case the executable name has a ".app" fragment which confuses our debugserver, 170433a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen // let's do an intentional fallthrough here... 170533a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen launch_flavor = eLaunchFlavorPosixSpawn; 170633a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen 170733a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen#endif 170833a9f647ab5122bfdc7c8cf358fba07b2cf7dedfJohnny Chen 170924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner case eLaunchFlavorPosixSpawn: 171020d338fad87eba91de65aa9bec76e01c04472848Greg Clayton m_pid = MachProcess::PosixSpawnChildForPTraceDebugging (path, 171197bd5670cdb415a95c84050c20cfacce8ed178e7Greg Clayton DNBArchProtocol::GetArchitecture (), 171220d338fad87eba91de65aa9bec76e01c04472848Greg Clayton argv, 171320d338fad87eba91de65aa9bec76e01c04472848Greg Clayton envp, 171472e1c782ba1e4226da37af4722af608de9f39408Greg Clayton working_directory, 171572e1c782ba1e4226da37af4722af608de9f39408Greg Clayton stdin_path, 171672e1c782ba1e4226da37af4722af608de9f39408Greg Clayton stdout_path, 171772e1c782ba1e4226da37af4722af608de9f39408Greg Clayton stderr_path, 1718bd666017403e102e0ca435d6da585ff979f83598Caroline Tice no_stdio, 171920d338fad87eba91de65aa9bec76e01c04472848Greg Clayton this, 172020d338fad87eba91de65aa9bec76e01c04472848Greg Clayton disable_aslr, 172120d338fad87eba91de65aa9bec76e01c04472848Greg Clayton launch_err); 172224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 172324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 172424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner default: 172524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Invalid launch 172624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic); 172724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 172824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 172924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 173024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_pid == INVALID_NUB_PROCESS) 173124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 173224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If we don't have a valid process ID and no one has set the error, 173324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // then return a generic error 173424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (launch_err.Success()) 173524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic); 173624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 173724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 173824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 173924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_path = path; 174024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t i; 174124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *arg; 174224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (i=0; (arg = argv[i]) != NULL; i++) 174324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_args.push_back(arg); 174424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 174535c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton m_task.StartExceptionThread(launch_err); 174635c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton if (launch_err.Fail()) 174724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 174835c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton if (launch_err.AsString() == NULL) 174935c0edcedb2058ca8d0758f71ce958c23836d52dGreg Clayton launch_err.SetErrorString("unable to start the exception thread"); 17508492942e52539a5c4fb4c06a865ad8479d496340Jason Molenda DNBLog ("Could not get inferior's Mach exception port, sending ptrace PT_KILL and exiting."); 175124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::ptrace (PT_KILL, m_pid, 0, 0); 175224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_pid = INVALID_NUB_PROCESS; 175324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 175424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 175524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 175624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner StartSTDIOThread(); 175724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 175824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (launch_flavor == eLaunchFlavorPosixSpawn) 175924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 176024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 176124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateAttaching); 176224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner errno = 0; 176390b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice int err = ::ptrace (PT_ATTACHEXC, m_pid, 0, 0); 176424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err == 0) 176524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 176624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags |= eMachProcessFlagsAttached; 176724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "successfully spawned pid %d", m_pid); 176824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.Clear(); 176924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 177024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 177124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 177224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateExited); 177324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError ptrace_err(errno, DNBError::POSIX); 177424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to spawned pid %d (err = %i, errno = %i (%s))", m_pid, err, ptrace_err.Error(), ptrace_err.AsString()); 177524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic); 177624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 177724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 177824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 177924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 178024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.Clear(); 178124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 178224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 178324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_pid; 178424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 178524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 178624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 178724943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::PosixSpawnChildForPTraceDebugging 178824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner( 178924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *path, 179020d338fad87eba91de65aa9bec76e01c04472848Greg Clayton cpu_type_t cpu_type, 179124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *argv[], 179224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *envp[], 179372e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *working_directory, 179472e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stdin_path, 179572e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stdout_path, 179672e1c782ba1e4226da37af4722af608de9f39408Greg Clayton const char *stderr_path, 1797bd666017403e102e0ca435d6da585ff979f83598Caroline Tice bool no_stdio, 179824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachProcess* process, 1799452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton int disable_aslr, 180024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError& err 180124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner) 180224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 180324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner posix_spawnattr_t attr; 1804452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton short flags; 1805de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv=%p, envp=%p, working_dir=%s, stdin=%s, stdout=%s stderr=%s, no-stdio=%i)", 1806de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton __FUNCTION__, 1807de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton path, 1808de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton argv, 1809de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton envp, 1810de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton working_directory, 1811de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton stdin_path, 1812de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton stdout_path, 1813de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton stderr_path, 1814de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton no_stdio); 181524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 181624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.SetError( ::posix_spawnattr_init (&attr), DNBError::POSIX); 181724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 181824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.LogThreaded("::posix_spawnattr_init ( &attr )"); 181924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail()) 182024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 182124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1822c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK; 1823452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton if (disable_aslr) 1824452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton flags |= _POSIX_SPAWN_DISABLE_ASLR; 1825c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton 1826c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton sigset_t no_signals; 1827c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton sigset_t all_signals; 1828c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton sigemptyset (&no_signals); 1829c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton sigfillset (&all_signals); 1830c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton ::posix_spawnattr_setsigmask(&attr, &no_signals); 1831c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton ::posix_spawnattr_setsigdefault(&attr, &all_signals); 1832c0977b917f414acf5612b20b72097a7281b217c1Greg Clayton 1833452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton err.SetError( ::posix_spawnattr_setflags (&attr, flags), DNBError::POSIX); 183424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 1835452bf613496c7290c6b7a1a1eb28efbce63fd3b9Greg Clayton err.LogThreaded("::posix_spawnattr_setflags ( &attr, POSIX_SPAWN_START_SUSPENDED%s )", flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR" : ""); 183624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail()) 183724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 183824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 183924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Don't do this on SnowLeopard, _sometimes_ the TASK_BASIC_INFO will fail 184024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // and we will fail to continue with our process... 184124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 184224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // On SnowLeopard we should set "DYLD_NO_PIE" in the inferior environment.... 184324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 184424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#if !defined(__arm__) 184524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 184624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We don't need to do this for ARM, and we really shouldn't now that we 184724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // have multiple CPU subtypes and no posix_spawnattr call that allows us 184824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // to set which CPU subtype to launch... 1849a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (cpu_type != 0) 1850a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton { 1851a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton size_t ocount = 0; 1852a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton err.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu_type, &ocount), DNBError::POSIX); 1853a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 1854851e30ec6a1b1d2c154bb7d69ed0d05b5fd14705Greg Clayton err.LogThreaded("::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %llu )", cpu_type, (uint64_t)ocount); 185524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1856a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (err.Fail() != 0 || ocount != 1) 1857a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton return INVALID_NUB_PROCESS; 1858a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton } 185924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#endif 186024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 186124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PseudoTerminal pty; 186224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 186324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner posix_spawn_file_actions_t file_actions; 186424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.SetError( ::posix_spawn_file_actions_init (&file_actions), DNBError::POSIX); 186524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int file_actions_valid = err.Success(); 186624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (!file_actions_valid || DNBLogCheckLogBit(LOG_PROCESS)) 186724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.LogThreaded("::posix_spawn_file_actions_init ( &file_actions )"); 186824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int pty_error = -1; 186924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pid_t pid = INVALID_NUB_PROCESS; 187024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (file_actions_valid) 187124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 187272e1c782ba1e4226da37af4722af608de9f39408Greg Clayton if (stdin_path == NULL && stdout_path == NULL && stderr_path == NULL && !no_stdio) 187324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 187424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pty_error = pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY); 187524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pty_error == PseudoTerminal::success) 187672e1c782ba1e4226da37af4722af608de9f39408Greg Clayton { 187772e1c782ba1e4226da37af4722af608de9f39408Greg Clayton stdin_path = stdout_path = stderr_path = pty.SlaveName(); 187872e1c782ba1e4226da37af4722af608de9f39408Greg Clayton } 187924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 188024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1881559cf6e8b52b940f5f4362b32d628838d6301e2eJason Molenda // if no_stdio or std paths not supplied, then route to "/dev/null". 1882053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (no_stdio || stdin_path == NULL || stdin_path[0] == '\0') 1883053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stdin_path = "/dev/null"; 1884053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (no_stdio || stdout_path == NULL || stdout_path[0] == '\0') 1885053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stdout_path = "/dev/null"; 1886053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (no_stdio || stderr_path == NULL || stderr_path[0] == '\0') 1887053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stderr_path = "/dev/null"; 1888053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 1889053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, 1890053a922033a915af17844296c95c3e77db9ed68bGreg Clayton STDIN_FILENO, 1891053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stdin_path, 1892053a922033a915af17844296c95c3e77db9ed68bGreg Clayton O_RDONLY | O_NOCTTY, 1893053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 0), 1894053a922033a915af17844296c95c3e77db9ed68bGreg Clayton DNBError::POSIX); 1895053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS)) 1896053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDIN_FILENO, path='%s')", stdin_path); 1897053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 1898053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, 1899053a922033a915af17844296c95c3e77db9ed68bGreg Clayton STDOUT_FILENO, 1900053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stdout_path, 1901053a922033a915af17844296c95c3e77db9ed68bGreg Clayton O_WRONLY | O_NOCTTY | O_CREAT, 1902053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 0640), 1903053a922033a915af17844296c95c3e77db9ed68bGreg Clayton DNBError::POSIX); 1904053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS)) 1905053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDOUT_FILENO, path='%s')", stdout_path); 1906053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 1907053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.SetError( ::posix_spawn_file_actions_addopen (&file_actions, 1908053a922033a915af17844296c95c3e77db9ed68bGreg Clayton STDERR_FILENO, 1909053a922033a915af17844296c95c3e77db9ed68bGreg Clayton stderr_path, 1910053a922033a915af17844296c95c3e77db9ed68bGreg Clayton O_WRONLY | O_NOCTTY | O_CREAT, 1911053a922033a915af17844296c95c3e77db9ed68bGreg Clayton 0640), 1912053a922033a915af17844296c95c3e77db9ed68bGreg Clayton DNBError::POSIX); 1913053a922033a915af17844296c95c3e77db9ed68bGreg Clayton if (err.Fail() || DNBLogCheckLogBit (LOG_PROCESS)) 1914053a922033a915af17844296c95c3e77db9ed68bGreg Clayton err.LogThreaded ("::posix_spawn_file_actions_addopen (&file_actions, filedes=STDERR_FILENO, path='%s')", stderr_path); 1915de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton 1916de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton // TODO: Verify if we can set the working directory back immediately 1917de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton // after the posix_spawnp call without creating a race condition??? 1918de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton if (working_directory) 1919de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton ::chdir (working_directory); 1920de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton 192124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.SetError( ::posix_spawnp (&pid, path, &file_actions, &attr, (char * const*)argv, (char * const*)envp), DNBError::POSIX); 192224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 192324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", pid, path, &file_actions, &attr, argv, envp); 192424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 192524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 192624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 1927de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton // TODO: Verify if we can set the working directory back immediately 1928de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton // after the posix_spawnp call without creating a race condition??? 1929de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton if (working_directory) 1930de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton ::chdir (working_directory); 1931de915beb5febe597505ba33fdc2c39eea2abdbd4Greg Clayton 193224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.SetError( ::posix_spawnp (&pid, path, NULL, &attr, (char * const*)argv, (char * const*)envp), DNBError::POSIX); 193324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 193424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", pid, path, NULL, &attr, argv, envp); 193524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 193624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 193724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // We have seen some cases where posix_spawnp was returning a valid 193824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // looking pid even when an error was returned, so clear it out 193924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err.Fail()) 194024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pid = INVALID_NUB_PROCESS; 194124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 194224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pty_error == 0) 194324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 194424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (process != NULL) 194524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 194624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int master_fd = pty.ReleaseMasterFD(); 194724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner process->SetChildFileDescriptors(master_fd, master_fd, master_fd); 194824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 194924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 1950e9d0df45df0ee87623985d1e59947a2ca50c14eaGreg Clayton ::posix_spawnattr_destroy (&attr); 195124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1952a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (pid != INVALID_NUB_PROCESS) 1953a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton { 1954a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton cpu_type_t pid_cpu_type = MachProcess::GetCPUTypeForLocalProcess (pid); 1955a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( ) pid=%i, cpu_type=0x%8.8x", __FUNCTION__, pid, pid_cpu_type); 1956a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (pid_cpu_type) 1957a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton DNBArchProtocol::SetArchitecture (pid_cpu_type); 1958a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton } 1959a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton 196024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (file_actions_valid) 196124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 196224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError err2; 196324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err2.SetError( ::posix_spawn_file_actions_destroy (&file_actions), DNBError::POSIX); 196424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err2.Fail() || DNBLogCheckLogBit(LOG_PROCESS)) 196524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err2.LogThreaded("::posix_spawn_file_actions_destroy ( &file_actions )"); 196624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 196724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 196824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return pid; 196924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 197024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 1971a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Claytonuint32_t 1972a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg ClaytonMachProcess::GetCPUTypeForLocalProcess (pid_t pid) 1973a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton{ 1974a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton int mib[CTL_MAXNAME]={0,}; 1975a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton size_t len = CTL_MAXNAME; 1976a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (::sysctlnametomib("sysctl.proc_cputype", mib, &len)) 1977a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton return 0; 1978a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton 1979a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton mib[len] = pid; 1980a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton len++; 1981a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton 1982a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton cpu_type_t cpu; 1983a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton size_t cpu_len = sizeof(cpu); 1984a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton if (::sysctl (mib, len, &cpu, &cpu_len, 0, 0)) 1985a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton cpu = 0; 1986a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton return cpu; 1987a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton} 1988a2f7423310044cf76d8d52aa9153b7fd8b226b49Greg Clayton 198924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 199024943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerMachProcess::ForkChildForPTraceDebugging 199124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner( 199224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *path, 199324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *argv[], 199424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *envp[], 199524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner MachProcess* process, 199624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBError& launch_err 199724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner) 199824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 199924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PseudoTerminal::Error pty_error = PseudoTerminal::success; 200024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 200124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Use a fork that ties the child process's stdin/out/err to a pseudo 200224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // terminal so we can read it in our MachProcess::STDIOThread 200324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // as unbuffered io. 200424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PseudoTerminal pty; 200524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pid_t pid = pty.Fork(pty_error); 200624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 200724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pid < 0) 200824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 200924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 201024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Error during fork. 201124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 201224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return pid; 201324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 201424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else if (pid == 0) 201524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 201624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 201724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Child process 201824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 201924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::ptrace (PT_TRACE_ME, 0, 0, 0); // Debug this process 202024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::ptrace (PT_SIGEXC, 0, 0, 0); // Get BSD signals as mach exceptions 202124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 202224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If our parent is setgid, lets make sure we don't inherit those 202324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // extra powers due to nepotism. 20244a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton if (::setgid (getgid ()) == 0) 20254a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton { 202624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 20274a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton // Let the child have its own process group. We need to execute 20284a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton // this call in both the child and parent to avoid a race condition 20294a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton // between the two processes. 20304a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton ::setpgid (0, 0); // Set the child process group to match its pid 203124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 20324a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton // Sleep a bit to before the exec call 20334a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton ::sleep (1); 203424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 20354a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton // Turn this process into 20364a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton ::execv (path, (char * const *)argv); 20374a379b1194f3e6b308cd6e80b45d6ca5dd0aafd7Greg Clayton } 203824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Exit with error code. Child process should have taken 203924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // over in above exec call and if the exec fails it will 204024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // exit the child process below. 204124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::exit (127); 204224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 204324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 204424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 204524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 204624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Parent process 204724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner //-------------------------------------------------------------- 204824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Let the child have its own process group. We need to execute 204924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // this call in both the child and parent to avoid a race condition 205024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // between the two processes. 205124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner ::setpgid (pid, pid); // Set the child process group to match its pid 205224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 205324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (process != NULL) 205424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 205524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Release our master pty file descriptor so the pty class doesn't 205624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // close it and so we can continue to use it in our STDIO thread 205724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int master_fd = pty.ReleaseMasterFD(); 205824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner process->SetChildFileDescriptors(master_fd, master_fd, master_fd); 205924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 206024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 206124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return pid; 206224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 206324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 20649a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#ifdef WITH_SPRINGBOARD 206524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 206624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 2067bd666017403e102e0ca435d6da585ff979f83598Caroline TiceMachProcess::SBLaunchForDebug (const char *path, char const *argv[], char const *envp[], bool no_stdio, DNBError &launch_err) 206824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 206924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Clear out and clean up from any current state 207024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Clear(); 207124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 207224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path); 207324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 207424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Fork a child process for debugging 207524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState(eStateLaunching); 2076bd666017403e102e0ca435d6da585ff979f83598Caroline Tice m_pid = MachProcess::SBForkChildForPTraceDebugging(path, argv, envp, no_stdio, this, launch_err); 207724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (m_pid != 0) 207824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 207924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags |= eMachProcessFlagsUsingSBS; 208024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_path = path; 208124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t i; 208224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *arg; 208324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (i=0; (arg = argv[i]) != NULL; i++) 208424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_args.push_back(arg); 20850a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton m_task.StartExceptionThread(launch_err); 20860a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton 20870a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton if (launch_err.Fail()) 20880a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton { 20890a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton if (launch_err.AsString() == NULL) 20900a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton launch_err.SetErrorString("unable to start the exception thread"); 20918492942e52539a5c4fb4c06a865ad8479d496340Jason Molenda DNBLog ("Could not get inferior's Mach exception port, sending ptrace PT_KILL and exiting."); 20920a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton ::ptrace (PT_KILL, m_pid, 0, 0); 20930a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton m_pid = INVALID_NUB_PROCESS; 20940a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton return INVALID_NUB_PROCESS; 20950a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton } 20960a7f75f9e375911ca91a884968b0efa36f18588dGreg Clayton 209724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner StartSTDIOThread(); 209824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateAttaching); 209990b42255ccebbaa31e0f692c6211f7490b2da371Caroline Tice int err = ::ptrace (PT_ATTACHEXC, m_pid, 0, 0); 210024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (err == 0) 210124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 210224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner m_flags |= eMachProcessFlagsAttached; 210324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid); 210424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 210524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 210624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 210724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SetState (eStateExited); 210824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid); 210924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 211024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 211124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return m_pid; 211224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 211324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 211424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner#include <servers/bootstrap.h> 211524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 211624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// This returns a CFRetained pointer to the Bundle ID for app_bundle_path, 211724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner// or NULL if there was some problem getting the bundle id. 211824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerstatic CFStringRef 211924943d2ee8bfaa7cf5893e4709143924157a5c1eChris LattnerCopyBundleIDForPath (const char *app_bundle_path, DNBError &err_str) 212024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 212124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFBundle bundle(app_bundle_path); 212224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFStringRef bundleIDCFStr = bundle.GetIdentifier(); 212324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner std::string bundleID; 212424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (CFString::UTF8(bundleIDCFStr, bundleID) == NULL) 212524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 212624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner struct stat app_bundle_stat; 212724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char err_msg[PATH_MAX]; 212824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 212924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (::stat (app_bundle_path, &app_bundle_stat) < 0) 213024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 213124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetError(errno, DNBError::POSIX); 213224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner snprintf(err_msg, sizeof(err_msg), "%s: \"%s\"", err_str.AsString(), app_bundle_path); 213324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetErrorString(err_msg); 213424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s() error: %s", __FUNCTION__, err_msg); 213524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 213624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 213724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 213824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetError(-1, DNBError::Generic); 213924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner snprintf(err_msg, sizeof(err_msg), "failed to extract CFBundleIdentifier from %s", app_bundle_path); 214024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner err_str.SetErrorString(err_msg); 214124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s() error: failed to extract CFBundleIdentifier from '%s'", __FUNCTION__, app_bundle_path); 214224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 214324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return NULL; 214424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 214524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 214624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s() extracted CFBundleIdentifier: %s", __FUNCTION__, bundleID.c_str()); 214724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFRetain (bundleIDCFStr); 214824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 214924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return bundleIDCFStr; 215024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 215124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 215224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattnerpid_t 2153bd666017403e102e0ca435d6da585ff979f83598Caroline TiceMachProcess::SBForkChildForPTraceDebugging (const char *app_bundle_path, char const *argv[], char const *envp[], bool no_stdio, MachProcess* process, DNBError &launch_err) 215424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner{ 215524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__, app_bundle_path, process); 215624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFAllocatorRef alloc = kCFAllocatorDefault; 215724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 215824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (argv[0] == NULL) 215924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 216024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 216124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t argc = 0; 216224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Count the number of arguments 216324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner while (argv[argc] != NULL) 216424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner argc++; 216524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 216624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Enumerate the arguments 216724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t first_launch_arg_idx = 1; 216824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFReleaser<CFMutableArrayRef> launch_argv; 216924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 217024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (argv[first_launch_arg_idx]) 217124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 217224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t launch_argc = argc > 0 ? argc - 1 : 0; 217324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_argv.reset (::CFArrayCreateMutable (alloc, launch_argc, &kCFTypeArrayCallBacks)); 217424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner size_t i; 217524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner char const *arg; 217624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString launch_arg; 217724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (i=first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL); i++) 217824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 217924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_arg.reset(::CFStringCreateWithCString (alloc, arg, kCFStringEncodingUTF8)); 218024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (launch_arg.get() != NULL) 218124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFArrayAppendValue(launch_argv.get(), launch_arg.get()); 218224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 218324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner break; 218424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 218524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 218624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 218724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Next fill in the arguments dictionary. Note, the envp array is of the form 218824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Variable=value but SpringBoard wants a CF dictionary. So we have to convert 218924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // this here. 219024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 219124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFReleaser<CFMutableDictionaryRef> launch_envp; 219224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 219324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (envp[0]) 219424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 219524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_envp.reset(::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks)); 219624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner const char *value; 219724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int name_len; 219824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString name_string, value_string; 219924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 220024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner for (int i = 0; envp[i] != NULL; i++) 220124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 220224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner value = strstr (envp[i], "="); 220324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 220424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // If the name field is empty or there's no =, skip it. Somebody's messing with us. 220524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (value == NULL || value == envp[i]) 220624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner continue; 220724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 220824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner name_len = value - envp[i]; 220924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 221024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Now move value over the "=" 221124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner value++; 221224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 221324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner name_string.reset(::CFStringCreateWithBytes(alloc, (const UInt8 *) envp[i], name_len, kCFStringEncodingUTF8, false)); 221424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner value_string.reset(::CFStringCreateWithCString(alloc, value, kCFStringEncodingUTF8)); 221524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFDictionarySetValue (launch_envp.get(), name_string.get(), value_string.get()); 221624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 221724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 221824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 221924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString stdio_path; 222024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 222124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner PseudoTerminal pty; 2222bd666017403e102e0ca435d6da585ff979f83598Caroline Tice if (!no_stdio) 222324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 2224bd666017403e102e0ca435d6da585ff979f83598Caroline Tice PseudoTerminal::Error pty_err = pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY); 2225bd666017403e102e0ca435d6da585ff979f83598Caroline Tice if (pty_err == PseudoTerminal::success) 222624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 2227bd666017403e102e0ca435d6da585ff979f83598Caroline Tice const char* slave_name = pty.SlaveName(); 2228bd666017403e102e0ca435d6da585ff979f83598Caroline Tice DNBLogThreadedIf(LOG_PROCESS, "%s() successfully opened master pty, slave is %s", __FUNCTION__, slave_name); 2229bd666017403e102e0ca435d6da585ff979f83598Caroline Tice if (slave_name && slave_name[0]) 2230bd666017403e102e0ca435d6da585ff979f83598Caroline Tice { 2231bd666017403e102e0ca435d6da585ff979f83598Caroline Tice ::chmod (slave_name, S_IRWXU | S_IRWXG | S_IRWXO); 2232bd666017403e102e0ca435d6da585ff979f83598Caroline Tice stdio_path.SetFileSystemRepresentation (slave_name); 2233bd666017403e102e0ca435d6da585ff979f83598Caroline Tice } 223424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 223524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 2236bd666017403e102e0ca435d6da585ff979f83598Caroline Tice 223724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (stdio_path.get() == NULL) 223824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 223924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.SetFileSystemRepresentation ("/dev/null"); 224024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 224124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 224224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFStringRef bundleIDCFStr = CopyBundleIDForPath (app_bundle_path, launch_err); 224324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (bundleIDCFStr == NULL) 224424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 224524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 224624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner std::string bundleID; 224724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFString::UTF8(bundleIDCFStr, bundleID); 224824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 224924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Find SpringBoard 225024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationLaunchError sbs_error = 0; 225124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner sbs_error = SBSLaunchApplicationForDebugging (bundleIDCFStr, 225224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner (CFURLRef)NULL, // openURL 225324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_argv.get(), 225424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_envp.get(), // CFDictionaryRef environment 225524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.get(), 225624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner stdio_path.get(), 225724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner SBSApplicationLaunchWaitForDebugger | SBSApplicationLaunchUnlockDevice); 225824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 225924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 226024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner launch_err.SetError(sbs_error, DNBError::SpringBoard); 226124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 226224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (sbs_error == SBSApplicationLaunchErrorSuccess) 226324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 226424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner static const useconds_t pid_poll_interval = 200000; 226524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner static const useconds_t pid_poll_timeout = 30000000; 226624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 226724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner useconds_t pid_poll_total = 0; 226824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 226924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner nub_process_t pid = INVALID_NUB_PROCESS; 227024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner Boolean pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid); 227124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Poll until the process is running, as long as we are getting valid responses and the timeout hasn't expired 227224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // A return PID of 0 means the process is not running, which may be because it hasn't been (asynchronously) started 227324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // yet, or that it died very quickly (if you weren't using waitForDebugger). 227424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner while (!pid_found && pid_poll_total < pid_poll_timeout) 227524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 227624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner usleep (pid_poll_interval); 227724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pid_poll_total += pid_poll_interval; 227824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s() polling Springboard for pid for %s...", __FUNCTION__, bundleID.c_str()); 227924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid); 228024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 228124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 228224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner CFRelease (bundleIDCFStr); 228324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (pid_found) 228424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 228524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner if (process != NULL) 228624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 228724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // Release our master pty file descriptor so the pty class doesn't 228824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner // close it and so we can continue to use it in our STDIO thread 228924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner int master_fd = pty.ReleaseMasterFD(); 229024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner process->SetChildFileDescriptors(master_fd, master_fd, master_fd); 229124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 229224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogThreadedIf(LOG_PROCESS, "%s() => pid = %4.4x", __FUNCTION__, pid); 229324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 229424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner else 229524943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner { 229624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogError("failed to lookup the process ID for CFBundleIdentifier %s.", bundleID.c_str()); 229724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 229824943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return pid; 229924943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner } 230024943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 230124943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner DNBLogError("unable to launch the application with CFBundleIdentifier '%s' sbs_error = %u", bundleID.c_str(), sbs_error); 230224943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner return INVALID_NUB_PROCESS; 230324943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner} 230424943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 23059a5bbd2a14cacac731424f7a253f6cc16b22c10aJason Molenda#endif // #ifdef WITH_SPRINGBOARD 230624943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 230724943d2ee8bfaa7cf5893e4709143924157a5c1eChris Lattner 2308