caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6c7bfc4d2bc37f55f57504c19d47deb7645dd76
clang-p2996/lldb/tools/debugserver/source/MacOSX/MachProcess.mm
Jason Molenda b0d33e9b3c Re-instate a bit of code that was commented out in r188246 which 
reads an ObjectFileMachO's string table in one chunk.  Originally
this was commented out because binaries in the system's shared cache
all share a mega-string table and so reading the entire mega-strtab
for each binary was a performance problem.

In the reinstated code, I add a check that the binary we're reading
from memory is not in the shared cache (there isn't a constant in
<mach-o/loader.h> for this bit yet; we hardcode the value in one
other place in ObjectFileMachO alread).  For binaries that we're
reading out of memory that are NOT in the shared cache, reading 
the string table in one chunk is a big performance improvement.

Also have debugserver send up the flags value for binaries in its
response to the jGetLoadedDynamicLibrariesInfos request.

NFC.

<rdar://problem/33604496> 

llvm-svn: 341511
2018-09-06 00:55:27 +00:00

3920 lines
142 KiB
C++
Raw Blame History

//===-- MachProcess.cpp -----------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Created by Greg Clayton on 6/15/07.
//
//===----------------------------------------------------------------------===//
#include "DNB.h"
#include "MacOSX/CFUtils.h"
#include "SysSignal.h"
#include <dlfcn.h>
#include <inttypes.h>
#include <mach-o/loader.h>
#include <mach/mach.h>
#include <mach/task.h>
#include <pthread.h>
#include <signal.h>
#include <spawn.h>
#include <sys/fcntl.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include <unistd.h>
#include <uuid/uuid.h>
#include <algorithm>
#include <map>
#import <Foundation/Foundation.h>
#include "DNBDataRef.h"
#include "DNBLog.h"
#include "DNBThreadResumeActions.h"
#include "DNBTimer.h"
#include "MachProcess.h"
#include "PseudoTerminal.h"
#include "CFBundle.h"
#include "CFString.h"
#ifdef WITH_SPRINGBOARD
#include <CoreFoundation/CoreFoundation.h>
#include <SpringBoardServices/SBSWatchdogAssertion.h>
#include <SpringBoardServices/SpringBoardServer.h>
static bool IsSBProcess(nub_process_t pid) {
CFReleaser<CFArrayRef> appIdsForPID(
::SBSCopyDisplayIdentifiersForProcessID(pid));
return appIdsForPID.get() != NULL;
}
#endif // WITH_SPRINGBOARD
#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
// This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
// or NULL if there was some problem getting the bundle id.
static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
DNBError &err_str);
#endif
#if defined(WITH_BKS) || defined(WITH_FBS)
#import <Foundation/Foundation.h>
static const int OPEN_APPLICATION_TIMEOUT_ERROR = 111;
typedef void (*SetErrorFunction)(NSInteger, DNBError &);
typedef bool (*CallOpenApplicationFunction)(NSString *bundleIDNSStr,
NSDictionary *options,
DNBError &error, pid_t *return_pid);
// This function runs the BKSSystemService (or FBSSystemService) method
// openApplication:options:clientPort:withResult,
// messaging the app passed in bundleIDNSStr.
// The function should be run inside of an NSAutoReleasePool.
//
// It will use the "options" dictionary passed in, and fill the error passed in
// if there is an error.
// If return_pid is not NULL, we'll fetch the pid that was made for the
// bundleID.
// If bundleIDNSStr is NULL, then the system application will be messaged.
template <typename OpenFlavor, typename ErrorFlavor,
ErrorFlavor no_error_enum_value, SetErrorFunction error_function>
static bool CallBoardSystemServiceOpenApplication(NSString *bundleIDNSStr,
NSDictionary *options,
DNBError &error,
pid_t *return_pid) {
// Now make our systemService:
OpenFlavor *system_service = [[OpenFlavor alloc] init];
if (bundleIDNSStr == nil) {
bundleIDNSStr = [system_service systemApplicationBundleIdentifier];
if (bundleIDNSStr == nil) {
// Okay, no system app...
error.SetErrorString("No system application to message.");
return false;
}
}
mach_port_t client_port = [system_service createClientPort];
__block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block ErrorFlavor open_app_error = no_error_enum_value;
bool wants_pid = (return_pid != NULL);
__block pid_t pid_in_block;
const char *cstr = [bundleIDNSStr UTF8String];
if (!cstr)
cstr = "<Unknown Bundle ID>";
NSString *description = [options description];
DNBLog("About to launch process for bundle ID: %s - options:\n%s", cstr,
[description UTF8String]);
[system_service
openApplication:bundleIDNSStr
options:options
clientPort:client_port
withResult:^(NSError *bks_error) {
// The system service will cleanup the client port we created for
// us.
if (bks_error)
open_app_error = (ErrorFlavor)[bks_error code];
if (open_app_error == no_error_enum_value) {
if (wants_pid) {
pid_in_block =
[system_service pidForApplication:bundleIDNSStr];
DNBLog(
"In completion handler, got pid for bundle id, pid: %d.",
pid_in_block);
DNBLogThreadedIf(
LOG_PROCESS,
"In completion handler, got pid for bundle id, pid: %d.",
pid_in_block);
} else
DNBLogThreadedIf(LOG_PROCESS,
"In completion handler: success.");
} else {
const char *error_str =
[(NSString *)[bks_error localizedDescription] UTF8String];
DNBLogThreadedIf(LOG_PROCESS, "In completion handler for send "
"event, got error \"%s\"(%ld).",
error_str ? error_str : "<unknown error>",
open_app_error);
// REMOVE ME
DNBLogError("In completion handler for send event, got error "
"\"%s\"(%ld).",
error_str ? error_str : "<unknown error>",
open_app_error);
}
[system_service release];
dispatch_semaphore_signal(semaphore);
}
];
const uint32_t timeout_secs = 30;
dispatch_time_t timeout =
dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
dispatch_release(semaphore);
if (!success) {
DNBLogError("timed out trying to send openApplication to %s.", cstr);
error.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
error.SetErrorString("timed out trying to launch app");
} else if (open_app_error != no_error_enum_value) {
error_function(open_app_error, error);
DNBLogError("unable to launch the application with CFBundleIdentifier '%s' "
"bks_error = %u",
cstr, open_app_error);
success = false;
} else if (wants_pid) {
*return_pid = pid_in_block;
DNBLogThreadedIf(
LOG_PROCESS,
"Out of completion handler, pid from block %d and passing out: %d",
pid_in_block, *return_pid);
}
return success;
}
#endif
#if defined(WITH_BKS) || defined(WITH_FBS)
static void SplitEventData(const char *data, std::vector<std::string> &elements)
{
elements.clear();
if (!data)
return;
const char *start = data;
while (*start != '\0') {
const char *token = strchr(start, ':');
if (!token) {
elements.push_back(std::string(start));
return;
}
if (token != start)
elements.push_back(std::string(start, token - start));
start = ++token;
}
}
#endif
#ifdef WITH_BKS
#import <Foundation/Foundation.h>
extern "C" {
#import <BackBoardServices/BKSOpenApplicationConstants_Private.h>
#import <BackBoardServices/BKSSystemService_LaunchServices.h>
#import <BackBoardServices/BackBoardServices.h>
}
static bool IsBKSProcess(nub_process_t pid) {
BKSApplicationStateMonitor *state_monitor =
[[BKSApplicationStateMonitor alloc] init];
BKSApplicationState app_state =
[state_monitor mostElevatedApplicationStateForPID:pid];
return app_state != BKSApplicationStateUnknown;
}
static void SetBKSError(NSInteger error_code, DNBError &error) {
error.SetError(error_code, DNBError::BackBoard);
NSString *err_nsstr = ::BKSOpenApplicationErrorCodeToString(
(BKSOpenApplicationErrorCode)error_code);
const char *err_str = NULL;
if (err_nsstr == NULL)
err_str = "unknown BKS error";
else {
err_str = [err_nsstr UTF8String];
if (err_str == NULL)
err_str = "unknown BKS error";
}
error.SetErrorString(err_str);
}
static bool BKSAddEventDataToOptions(NSMutableDictionary *options,
const char *event_data,
DNBError &option_error) {
std::vector<std::string> values;
SplitEventData(event_data, values);
bool found_one = false;
for (std::string value : values)
{
if (value.compare("BackgroundContentFetching") == 0) {
DNBLog("Setting ActivateForEvent key in options dictionary.");
NSDictionary *event_details = [NSDictionary dictionary];
NSDictionary *event_dictionary = [NSDictionary
dictionaryWithObject:event_details
forKey:
BKSActivateForEventOptionTypeBackgroundContentFetching];
[options setObject:event_dictionary
forKey:BKSOpenApplicationOptionKeyActivateForEvent];
found_one = true;
} else if (value.compare("ActivateSuspended") == 0) {
DNBLog("Setting ActivateSuspended key in options dictionary.");
[options setObject:@YES forKey: BKSOpenApplicationOptionKeyActivateSuspended];
found_one = true;
} else {
DNBLogError("Unrecognized event type: %s. Ignoring.", value.c_str());
option_error.SetErrorString("Unrecognized event data");
}
}
return found_one;
}
static NSMutableDictionary *BKSCreateOptionsDictionary(
const char *app_bundle_path, NSMutableArray *launch_argv,
NSMutableDictionary *launch_envp, NSString *stdio_path, bool disable_aslr,
const char *event_data) {
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
if (launch_argv != nil)
[debug_options setObject:launch_argv forKey:BKSDebugOptionKeyArguments];
if (launch_envp != nil)
[debug_options setObject:launch_envp forKey:BKSDebugOptionKeyEnvironment];
[debug_options setObject:stdio_path forKey:BKSDebugOptionKeyStandardOutPath];
[debug_options setObject:stdio_path
forKey:BKSDebugOptionKeyStandardErrorPath];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:BKSDebugOptionKeyWaitForDebugger];
if (disable_aslr)
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:BKSDebugOptionKeyDisableASLR];
// That will go in the overall dictionary:
NSMutableDictionary *options = [NSMutableDictionary dictionary];
[options setObject:debug_options
forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
// And there are some other options at the top level in this dictionary:
[options setObject:[NSNumber numberWithBool:YES]
forKey:BKSOpenApplicationOptionKeyUnlockDevice];
DNBError error;
BKSAddEventDataToOptions(options, event_data, error);
return options;
}
static CallOpenApplicationFunction BKSCallOpenApplicationFunction =
CallBoardSystemServiceOpenApplication<
BKSSystemService, BKSOpenApplicationErrorCode,
BKSOpenApplicationErrorCodeNone, SetBKSError>;
#endif // WITH_BKS
#ifdef WITH_FBS
#import <Foundation/Foundation.h>
extern "C" {
#import <FrontBoardServices/FBSOpenApplicationConstants_Private.h>
#import <FrontBoardServices/FBSSystemService_LaunchServices.h>
#import <FrontBoardServices/FrontBoardServices.h>
#import <MobileCoreServices/LSResourceProxy.h>
#import <MobileCoreServices/MobileCoreServices.h>
}
#ifdef WITH_BKS
static bool IsFBSProcess(nub_process_t pid) {
BKSApplicationStateMonitor *state_monitor =
[[BKSApplicationStateMonitor alloc] init];
BKSApplicationState app_state =
[state_monitor mostElevatedApplicationStateForPID:pid];
return app_state != BKSApplicationStateUnknown;
}
#else
static bool IsFBSProcess(nub_process_t pid) {
// FIXME: What is the FBS equivalent of BKSApplicationStateMonitor
return true;
}
#endif
static void SetFBSError(NSInteger error_code, DNBError &error) {
error.SetError((DNBError::ValueType)error_code, DNBError::FrontBoard);
NSString *err_nsstr = ::FBSOpenApplicationErrorCodeToString(
(FBSOpenApplicationErrorCode)error_code);
const char *err_str = NULL;
if (err_nsstr == NULL)
err_str = "unknown FBS error";
else {
err_str = [err_nsstr UTF8String];
if (err_str == NULL)
err_str = "unknown FBS error";
}
error.SetErrorString(err_str);
}
static bool FBSAddEventDataToOptions(NSMutableDictionary *options,
const char *event_data,
DNBError &option_error) {
std::vector<std::string> values;
SplitEventData(event_data, values);
bool found_one = false;
for (std::string value : values)
{
if (value.compare("BackgroundContentFetching") == 0) {
DNBLog("Setting ActivateForEvent key in options dictionary.");
NSDictionary *event_details = [NSDictionary dictionary];
NSDictionary *event_dictionary = [NSDictionary
dictionaryWithObject:event_details
forKey:
FBSActivateForEventOptionTypeBackgroundContentFetching];
[options setObject:event_dictionary
forKey:FBSOpenApplicationOptionKeyActivateForEvent];
found_one = true;
} else if (value.compare("ActivateSuspended") == 0) {
DNBLog("Setting ActivateSuspended key in options dictionary.");
[options setObject:@YES forKey: FBSOpenApplicationOptionKeyActivateSuspended];
found_one = true;
} else {
DNBLogError("Unrecognized event type: %s. Ignoring.", value.c_str());
option_error.SetErrorString("Unrecognized event data.");
}
}
return found_one;
}
static NSMutableDictionary *
FBSCreateOptionsDictionary(const char *app_bundle_path,
NSMutableArray *launch_argv,
NSDictionary *launch_envp, NSString *stdio_path,
bool disable_aslr, const char *event_data) {
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
if (launch_argv != nil)
[debug_options setObject:launch_argv forKey:FBSDebugOptionKeyArguments];
if (launch_envp != nil)
[debug_options setObject:launch_envp forKey:FBSDebugOptionKeyEnvironment];
[debug_options setObject:stdio_path forKey:FBSDebugOptionKeyStandardOutPath];
[debug_options setObject:stdio_path
forKey:FBSDebugOptionKeyStandardErrorPath];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:FBSDebugOptionKeyWaitForDebugger];
if (disable_aslr)
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:FBSDebugOptionKeyDisableASLR];
// That will go in the overall dictionary:
NSMutableDictionary *options = [NSMutableDictionary dictionary];
[options setObject:debug_options
forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
// And there are some other options at the top level in this dictionary:
[options setObject:[NSNumber numberWithBool:YES]
forKey:FBSOpenApplicationOptionKeyUnlockDevice];
// We have to get the "sequence ID & UUID" for this app bundle path and send
// them to FBS:
NSURL *app_bundle_url =
[NSURL fileURLWithPath:[NSString stringWithUTF8String:app_bundle_path]
isDirectory:YES];
LSApplicationProxy *app_proxy =
[LSApplicationProxy applicationProxyForBundleURL:app_bundle_url];
if (app_proxy) {
DNBLog("Sending AppProxy info: sequence no: %lu, GUID: %s.",
app_proxy.sequenceNumber,
[app_proxy.cacheGUID.UUIDString UTF8String]);
[options
setObject:[NSNumber numberWithUnsignedInteger:app_proxy.sequenceNumber]
forKey:FBSOpenApplicationOptionKeyLSSequenceNumber];
[options setObject:app_proxy.cacheGUID.UUIDString
forKey:FBSOpenApplicationOptionKeyLSCacheGUID];
}
DNBError error;
FBSAddEventDataToOptions(options, event_data, error);
return options;
}
static CallOpenApplicationFunction FBSCallOpenApplicationFunction =
CallBoardSystemServiceOpenApplication<
FBSSystemService, FBSOpenApplicationErrorCode,
FBSOpenApplicationErrorCodeNone, SetFBSError>;
#endif // WITH_FBS
#if 0
#define DEBUG_LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#define DEBUG_LOG(fmt, ...)
#endif
#ifndef MACH_PROCESS_USE_POSIX_SPAWN
#define MACH_PROCESS_USE_POSIX_SPAWN 1
#endif
#ifndef _POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
#endif
MachProcess::MachProcess()
: m_pid(0), m_cpu_type(0), m_child_stdin(-1), m_child_stdout(-1),
m_child_stderr(-1), m_path(), m_args(), m_task(this),
m_flags(eMachProcessFlagsNone), m_stdio_thread(0),
m_stdio_mutex(PTHREAD_MUTEX_RECURSIVE), m_stdout_data(),
m_profile_enabled(false), m_profile_interval_usec(0), m_profile_thread(0),
m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE), m_profile_data(),
m_thread_actions(), m_exception_messages(),
m_exception_messages_mutex(PTHREAD_MUTEX_RECURSIVE), m_thread_list(),
m_activities(), m_state(eStateUnloaded),
m_state_mutex(PTHREAD_MUTEX_RECURSIVE), m_events(0, kAllEventsMask),
m_private_events(0, kAllEventsMask), m_breakpoints(), m_watchpoints(),
m_name_to_addr_callback(NULL), m_name_to_addr_baton(NULL),
m_image_infos_callback(NULL), m_image_infos_baton(NULL),
m_sent_interrupt_signo(0), m_auto_resume_signo(0), m_did_exec(false),
m_dyld_process_info_create(nullptr),
m_dyld_process_info_for_each_image(nullptr),
m_dyld_process_info_release(nullptr),
m_dyld_process_info_get_cache(nullptr) {
m_dyld_process_info_create =
(void *(*)(task_t task, uint64_t timestamp, kern_return_t * kernelError))
dlsym(RTLD_DEFAULT, "_dyld_process_info_create");
m_dyld_process_info_for_each_image =
(void (*)(void *info, void (^)(uint64_t machHeaderAddress,
const uuid_t uuid, const char *path)))
dlsym(RTLD_DEFAULT, "_dyld_process_info_for_each_image");
m_dyld_process_info_release =
(void (*)(void *info))dlsym(RTLD_DEFAULT, "_dyld_process_info_release");
m_dyld_process_info_get_cache = (void (*)(void *info, void *cacheInfo))dlsym(
RTLD_DEFAULT, "_dyld_process_info_get_cache");
DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
}
MachProcess::~MachProcess() {
DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
Clear();
}
pid_t MachProcess::SetProcessID(pid_t pid) {
// Free any previous process specific data or resources
Clear();
// Set the current PID appropriately
if (pid == 0)
m_pid = ::getpid();
else
m_pid = pid;
return m_pid; // Return actually PID in case a zero pid was passed in
}
nub_state_t MachProcess::GetState() {
// If any other threads access this we will need a mutex for it
PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
return m_state;
}
const char *MachProcess::ThreadGetName(nub_thread_t tid) {
return m_thread_list.GetName(tid);
}
nub_state_t MachProcess::ThreadGetState(nub_thread_t tid) {
return m_thread_list.GetState(tid);
}
nub_size_t MachProcess::GetNumThreads() const {
return m_thread_list.NumThreads();
}
nub_thread_t MachProcess::GetThreadAtIndex(nub_size_t thread_idx) const {
return m_thread_list.ThreadIDAtIndex(thread_idx);
}
nub_thread_t
MachProcess::GetThreadIDForMachPortNumber(thread_t mach_port_number) const {
return m_thread_list.GetThreadIDByMachPortNumber(mach_port_number);
}
nub_bool_t MachProcess::SyncThreadState(nub_thread_t tid) {
MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
if (!thread_sp)
return false;
kern_return_t kret = ::thread_abort_safely(thread_sp->MachPortNumber());
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());
if (kret == KERN_SUCCESS)
return true;
else
return false;
}
ThreadInfo::QoS MachProcess::GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd,
uint64_t dti_qos_class_index) {
return m_thread_list.GetRequestedQoS(tid, tsd, dti_qos_class_index);
}
nub_addr_t MachProcess::GetPThreadT(nub_thread_t tid) {
return m_thread_list.GetPThreadT(tid);
}
nub_addr_t MachProcess::GetDispatchQueueT(nub_thread_t tid) {
return m_thread_list.GetDispatchQueueT(tid);
}
nub_addr_t MachProcess::GetTSDAddressForThread(
nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset,
uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size) {
return m_thread_list.GetTSDAddressForThread(
tid, plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset,
plo_pthread_tsd_entry_size);
}
const char *MachProcess::GetDeploymentInfo(const struct load_command& lc,
uint64_t load_command_address,
uint32_t& major_version,
uint32_t& minor_version,
uint32_t& patch_version) {
uint32_t cmd = lc.cmd & ~LC_REQ_DYLD;
bool lc_cmd_known =
cmd == LC_VERSION_MIN_IPHONEOS || cmd == LC_VERSION_MIN_MACOSX ||
cmd == LC_VERSION_MIN_TVOS || cmd == LC_VERSION_MIN_WATCHOS;
if (lc_cmd_known) {
struct version_min_command vers_cmd;
if (ReadMemory(load_command_address, sizeof(struct version_min_command),
&vers_cmd) != sizeof(struct version_min_command)) {
return nullptr;
}
major_version = vers_cmd.sdk >> 16;
minor_version = (vers_cmd.sdk >> 8) & 0xffu;
patch_version = vers_cmd.sdk & 0xffu;
switch (cmd) {
case LC_VERSION_MIN_IPHONEOS:
return "ios";
case LC_VERSION_MIN_MACOSX:
return "macosx";
case LC_VERSION_MIN_TVOS:
return "tvos";
case LC_VERSION_MIN_WATCHOS:
return "watchos";
default:
return nullptr;
}
}
#if defined (LC_BUILD_VERSION)
#ifndef PLATFORM_IOSSIMULATOR
#define PLATFORM_IOSSIMULATOR 7
#define PLATFORM_TVOSSIMULATOR 8
#define PLATFORM_WATCHOSSIMULATOR 9
#endif
if (cmd == LC_BUILD_VERSION) {
struct build_version_command build_vers;
if (ReadMemory(load_command_address, sizeof(struct build_version_command),
&build_vers) != sizeof(struct build_version_command)) {
return nullptr;
}
major_version = build_vers.sdk >> 16;;
minor_version = (build_vers.sdk >> 8) & 0xffu;
patch_version = build_vers.sdk & 0xffu;
switch (build_vers.platform) {
case PLATFORM_MACOS:
return "macosx";
case PLATFORM_IOS:
case PLATFORM_IOSSIMULATOR:
return "ios";
case PLATFORM_TVOS:
case PLATFORM_TVOSSIMULATOR:
return "tvos";
case PLATFORM_WATCHOS:
case PLATFORM_WATCHOSSIMULATOR:
return "watchos";
case PLATFORM_BRIDGEOS:
return "bridgeos";
}
}
#endif
return nullptr;
}
// Given an address, read the mach-o header and load commands out of memory to
// fill in
// the mach_o_information "inf" object.
//
// Returns false if there was an error in reading this mach-o file header/load
// commands.
bool MachProcess::GetMachOInformationFromMemory(
nub_addr_t mach_o_header_addr, int wordsize,
struct mach_o_information &inf) {
uint64_t load_cmds_p;
if (wordsize == 4) {
struct mach_header header;
if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header), &header) !=
sizeof(struct mach_header)) {
return false;
}
load_cmds_p = mach_o_header_addr + sizeof(struct mach_header);
inf.mach_header.magic = header.magic;
inf.mach_header.cputype = header.cputype;
// high byte of cpusubtype is used for "capability bits", v.
// CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
inf.mach_header.filetype = header.filetype;
inf.mach_header.ncmds = header.ncmds;
inf.mach_header.sizeofcmds = header.sizeofcmds;
inf.mach_header.flags = header.flags;
} else {
struct mach_header_64 header;
if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header_64),
&header) != sizeof(struct mach_header_64)) {
return false;
}
load_cmds_p = mach_o_header_addr + sizeof(struct mach_header_64);
inf.mach_header.magic = header.magic;
inf.mach_header.cputype = header.cputype;
// high byte of cpusubtype is used for "capability bits", v.
// CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
inf.mach_header.filetype = header.filetype;
inf.mach_header.ncmds = header.ncmds;
inf.mach_header.sizeofcmds = header.sizeofcmds;
inf.mach_header.flags = header.flags;
}
for (uint32_t j = 0; j < inf.mach_header.ncmds; j++) {
struct load_command lc;
if (ReadMemory(load_cmds_p, sizeof(struct load_command), &lc) !=
sizeof(struct load_command)) {
return false;
}
if (lc.cmd == LC_SEGMENT) {
struct segment_command seg;
if (ReadMemory(load_cmds_p, sizeof(struct segment_command), &seg) !=
sizeof(struct segment_command)) {
return false;
}
struct mach_o_segment this_seg;
char name[17];
::memset(name, 0, sizeof(name));
memcpy(name, seg.segname, sizeof(seg.segname));
this_seg.name = name;
this_seg.vmaddr = seg.vmaddr;
this_seg.vmsize = seg.vmsize;
this_seg.fileoff = seg.fileoff;
this_seg.filesize = seg.filesize;
this_seg.maxprot = seg.maxprot;
this_seg.initprot = seg.initprot;
this_seg.nsects = seg.nsects;
this_seg.flags = seg.flags;
inf.segments.push_back(this_seg);
}
if (lc.cmd == LC_SEGMENT_64) {
struct segment_command_64 seg;
if (ReadMemory(load_cmds_p, sizeof(struct segment_command_64), &seg) !=
sizeof(struct segment_command_64)) {
return false;
}
struct mach_o_segment this_seg;
char name[17];
::memset(name, 0, sizeof(name));
memcpy(name, seg.segname, sizeof(seg.segname));
this_seg.name = name;
this_seg.vmaddr = seg.vmaddr;
this_seg.vmsize = seg.vmsize;
this_seg.fileoff = seg.fileoff;
this_seg.filesize = seg.filesize;
this_seg.maxprot = seg.maxprot;
this_seg.initprot = seg.initprot;
this_seg.nsects = seg.nsects;
this_seg.flags = seg.flags;
inf.segments.push_back(this_seg);
}
if (lc.cmd == LC_UUID) {
struct uuid_command uuidcmd;
if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
sizeof(struct uuid_command))
uuid_copy(inf.uuid, uuidcmd.uuid);
}
uint32_t major_version, minor_version, patch_version;
if (const char *platform = GetDeploymentInfo(lc, load_cmds_p,
major_version, minor_version,
patch_version)) {
inf.min_version_os_name = platform;
inf.min_version_os_version = "";
inf.min_version_os_version += std::to_string(major_version);
inf.min_version_os_version += ".";
inf.min_version_os_version += std::to_string(minor_version);
if (patch_version != 0) {
inf.min_version_os_version += ".";
inf.min_version_os_version += std::to_string(patch_version);
}
}
load_cmds_p += lc.cmdsize;
}
return true;
}
// Given completely filled in array of binary_image_information structures,
// create a JSONGenerator object
// with all the details we want to send to lldb.
JSONGenerator::ObjectSP MachProcess::FormatDynamicLibrariesIntoJSON(
const std::vector<struct binary_image_information> &image_infos) {
JSONGenerator::ArraySP image_infos_array_sp(new JSONGenerator::Array());
const size_t image_count = image_infos.size();
for (size_t i = 0; i < image_count; i++) {
JSONGenerator::DictionarySP image_info_dict_sp(
new JSONGenerator::Dictionary());
image_info_dict_sp->AddIntegerItem("load_address",
image_infos[i].load_address);
image_info_dict_sp->AddIntegerItem("mod_date", image_infos[i].mod_date);
image_info_dict_sp->AddStringItem("pathname", image_infos[i].filename);
uuid_string_t uuidstr;
uuid_unparse_upper(image_infos[i].macho_info.uuid, uuidstr);
image_info_dict_sp->AddStringItem("uuid", uuidstr);
if (image_infos[i].macho_info.min_version_os_name.empty() == false &&
image_infos[i].macho_info.min_version_os_version.empty() == false) {
image_info_dict_sp->AddStringItem(
"min_version_os_name", image_infos[i].macho_info.min_version_os_name);
image_info_dict_sp->AddStringItem(
"min_version_os_sdk",
image_infos[i].macho_info.min_version_os_version);
}
JSONGenerator::DictionarySP mach_header_dict_sp(
new JSONGenerator::Dictionary());
mach_header_dict_sp->AddIntegerItem(
"magic", image_infos[i].macho_info.mach_header.magic);
mach_header_dict_sp->AddIntegerItem(
"cputype", (uint32_t)image_infos[i].macho_info.mach_header.cputype);
mach_header_dict_sp->AddIntegerItem(
"cpusubtype",
(uint32_t)image_infos[i].macho_info.mach_header.cpusubtype);
mach_header_dict_sp->AddIntegerItem(
"filetype", image_infos[i].macho_info.mach_header.filetype);
mach_header_dict_sp->AddIntegerItem ("flags",
image_infos[i].macho_info.mach_header.flags);
// DynamicLoaderMacOSX doesn't currently need these fields, so
// don't send them.
// mach_header_dict_sp->AddIntegerItem ("ncmds",
// image_infos[i].macho_info.mach_header.ncmds);
// mach_header_dict_sp->AddIntegerItem ("sizeofcmds",
// image_infos[i].macho_info.mach_header.sizeofcmds);
image_info_dict_sp->AddItem("mach_header", mach_header_dict_sp);
JSONGenerator::ArraySP segments_sp(new JSONGenerator::Array());
for (size_t j = 0; j < image_infos[i].macho_info.segments.size(); j++) {
JSONGenerator::DictionarySP segment_sp(new JSONGenerator::Dictionary());
segment_sp->AddStringItem("name",
image_infos[i].macho_info.segments[j].name);
segment_sp->AddIntegerItem("vmaddr",
image_infos[i].macho_info.segments[j].vmaddr);
segment_sp->AddIntegerItem("vmsize",
image_infos[i].macho_info.segments[j].vmsize);
segment_sp->AddIntegerItem("fileoff",
image_infos[i].macho_info.segments[j].fileoff);
segment_sp->AddIntegerItem(
"filesize", image_infos[i].macho_info.segments[j].filesize);
segment_sp->AddIntegerItem("maxprot",
image_infos[i].macho_info.segments[j].maxprot);
// DynamicLoaderMacOSX doesn't currently need these fields,
// so don't send them.
// segment_sp->AddIntegerItem ("initprot",
// image_infos[i].macho_info.segments[j].initprot);
// segment_sp->AddIntegerItem ("nsects",
// image_infos[i].macho_info.segments[j].nsects);
// segment_sp->AddIntegerItem ("flags",
// image_infos[i].macho_info.segments[j].flags);
segments_sp->AddItem(segment_sp);
}
image_info_dict_sp->AddItem("segments", segments_sp);
image_infos_array_sp->AddItem(image_info_dict_sp);
}
JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
;
reply_sp->AddItem("images", image_infos_array_sp);
return reply_sp;
}
// Get the shared library information using the old (pre-macOS 10.12, pre-iOS
// 10, pre-tvOS 10, pre-watchOS 3)
// code path. We'll be given the address of an array of structures in the form
// {void* load_addr, void* mod_date, void* pathname}
//
// In macOS 10.12 etc and newer, we'll use SPI calls into dyld to gather this
// information.
JSONGenerator::ObjectSP MachProcess::GetLoadedDynamicLibrariesInfos(
nub_process_t pid, nub_addr_t image_list_address, nub_addr_t image_count) {
JSONGenerator::DictionarySP reply_sp;
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
struct kinfo_proc processInfo;
size_t bufsize = sizeof(processInfo);
if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
NULL, 0) == 0 &&
bufsize > 0) {
uint32_t pointer_size = 4;
if (processInfo.kp_proc.p_flag & P_LP64)
pointer_size = 8;
std::vector<struct binary_image_information> image_infos;
size_t image_infos_size = image_count * 3 * pointer_size;
uint8_t *image_info_buf = (uint8_t *)malloc(image_infos_size);
if (image_info_buf == NULL) {
return reply_sp;
}
if (ReadMemory(image_list_address, image_infos_size, image_info_buf) !=
image_infos_size) {
return reply_sp;
}
//// First the image_infos array with (load addr, pathname, mod date)
///tuples
for (size_t i = 0; i < image_count; i++) {
struct binary_image_information info;
nub_addr_t pathname_address;
if (pointer_size == 4) {
uint32_t load_address_32;
uint32_t pathname_address_32;
uint32_t mod_date_32;
::memcpy(&load_address_32, image_info_buf + (i * 3 * pointer_size), 4);
::memcpy(&pathname_address_32,
image_info_buf + (i * 3 * pointer_size) + pointer_size, 4);
::memcpy(&mod_date_32, image_info_buf + (i * 3 * pointer_size) +
pointer_size + pointer_size,
4);
info.load_address = load_address_32;
info.mod_date = mod_date_32;
pathname_address = pathname_address_32;
} else {
uint64_t load_address_64;
uint64_t pathname_address_64;
uint64_t mod_date_64;
::memcpy(&load_address_64, image_info_buf + (i * 3 * pointer_size), 8);
::memcpy(&pathname_address_64,
image_info_buf + (i * 3 * pointer_size) + pointer_size, 8);
::memcpy(&mod_date_64, image_info_buf + (i * 3 * pointer_size) +
pointer_size + pointer_size,
8);
info.load_address = load_address_64;
info.mod_date = mod_date_64;
pathname_address = pathname_address_64;
}
char strbuf[17];
info.filename = "";
uint64_t pathname_ptr = pathname_address;
bool still_reading = true;
while (still_reading &&
ReadMemory(pathname_ptr, sizeof(strbuf) - 1, strbuf) ==
sizeof(strbuf) - 1) {
strbuf[sizeof(strbuf) - 1] = '\0';
info.filename += strbuf;
pathname_ptr += sizeof(strbuf) - 1;
// Stop if we found nul byte indicating the end of the string
for (size_t i = 0; i < sizeof(strbuf) - 1; i++) {
if (strbuf[i] == '\0') {
still_reading = false;
break;
}
}
}
uuid_clear(info.macho_info.uuid);
image_infos.push_back(info);
}
if (image_infos.size() == 0) {
return reply_sp;
}
free(image_info_buf);
//// Second, read the mach header / load commands for all the dylibs
for (size_t i = 0; i < image_count; i++) {
if (!GetMachOInformationFromMemory(image_infos[i].load_address,
pointer_size,
image_infos[i].macho_info)) {
return reply_sp;
}
}
//// Third, format all of the above in the JSONGenerator object.
return FormatDynamicLibrariesIntoJSON(image_infos);
}
return reply_sp;
}
// From dyld SPI header dyld_process_info.h
typedef void *dyld_process_info;
struct dyld_process_cache_info {
uuid_t cacheUUID; // UUID of cache used by process
uint64_t cacheBaseAddress; // load address of dyld shared cache
bool noCache; // process is running without a dyld cache
bool privateCache; // process is using a private copy of its dyld cache
};
// Use the dyld SPI present in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer
// to get
// the load address, uuid, and filenames of all the libraries.
// This only fills in those three fields in the 'struct
// binary_image_information' - call
// GetMachOInformationFromMemory to fill in the mach-o header/load command
// details.
void MachProcess::GetAllLoadedBinariesViaDYLDSPI(
std::vector<struct binary_image_information> &image_infos) {
kern_return_t kern_ret;
if (m_dyld_process_info_create) {
dyld_process_info info =
m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
if (info) {
m_dyld_process_info_for_each_image(
info,
^(uint64_t mach_header_addr, const uuid_t uuid, const char *path) {
struct binary_image_information image;
image.filename = path;
uuid_copy(image.macho_info.uuid, uuid);
image.load_address = mach_header_addr;
image_infos.push_back(image);
});
m_dyld_process_info_release(info);
}
}
}
// Fetch information about all shared libraries using the dyld SPIs that exist
// in
// macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
JSONGenerator::ObjectSP
MachProcess::GetAllLoadedLibrariesInfos(nub_process_t pid) {
JSONGenerator::DictionarySP reply_sp;
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
struct kinfo_proc processInfo;
size_t bufsize = sizeof(processInfo);
if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
NULL, 0) == 0 &&
bufsize > 0) {
uint32_t pointer_size = 4;
if (processInfo.kp_proc.p_flag & P_LP64)
pointer_size = 8;
std::vector<struct binary_image_information> image_infos;
GetAllLoadedBinariesViaDYLDSPI(image_infos);
const size_t image_count = image_infos.size();
for (size_t i = 0; i < image_count; i++) {
GetMachOInformationFromMemory(image_infos[i].load_address, pointer_size,
image_infos[i].macho_info);
}
return FormatDynamicLibrariesIntoJSON(image_infos);
}
return reply_sp;
}
// Fetch information about the shared libraries at the given load addresses
// using the
// dyld SPIs that exist in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
JSONGenerator::ObjectSP MachProcess::GetLibrariesInfoForAddresses(
nub_process_t pid, std::vector<uint64_t> &macho_addresses) {
JSONGenerator::DictionarySP reply_sp;
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
struct kinfo_proc processInfo;
size_t bufsize = sizeof(processInfo);
if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
NULL, 0) == 0 &&
bufsize > 0) {
uint32_t pointer_size = 4;
if (processInfo.kp_proc.p_flag & P_LP64)
pointer_size = 8;
std::vector<struct binary_image_information> all_image_infos;
GetAllLoadedBinariesViaDYLDSPI(all_image_infos);
std::vector<struct binary_image_information> image_infos;
const size_t macho_addresses_count = macho_addresses.size();
const size_t all_image_infos_count = all_image_infos.size();
for (size_t i = 0; i < macho_addresses_count; i++) {
for (size_t j = 0; j < all_image_infos_count; j++) {
if (all_image_infos[j].load_address == macho_addresses[i]) {
image_infos.push_back(all_image_infos[j]);
}
}
}
const size_t image_infos_count = image_infos.size();
for (size_t i = 0; i < image_infos_count; i++) {
GetMachOInformationFromMemory(image_infos[i].load_address, pointer_size,
image_infos[i].macho_info);
}
return FormatDynamicLibrariesIntoJSON(image_infos);
}
return reply_sp;
}
// From dyld's internal podyld_process_info.h:
JSONGenerator::ObjectSP MachProcess::GetSharedCacheInfo(nub_process_t pid) {
JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
;
kern_return_t kern_ret;
if (m_dyld_process_info_create && m_dyld_process_info_get_cache) {
dyld_process_info info =
m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
if (info) {
struct dyld_process_cache_info shared_cache_info;
m_dyld_process_info_get_cache(info, &shared_cache_info);
reply_sp->AddIntegerItem("shared_cache_base_address",
shared_cache_info.cacheBaseAddress);
uuid_string_t uuidstr;
uuid_unparse_upper(shared_cache_info.cacheUUID, uuidstr);
reply_sp->AddStringItem("shared_cache_uuid", uuidstr);
reply_sp->AddBooleanItem("no_shared_cache", shared_cache_info.noCache);
reply_sp->AddBooleanItem("shared_cache_private_cache",
shared_cache_info.privateCache);
m_dyld_process_info_release(info);
}
}
return reply_sp;
}
nub_thread_t MachProcess::GetCurrentThread() {
return m_thread_list.CurrentThreadID();
}
nub_thread_t MachProcess::GetCurrentThreadMachPort() {
return m_thread_list.GetMachPortNumberByThreadID(
m_thread_list.CurrentThreadID());
}
nub_thread_t MachProcess::SetCurrentThread(nub_thread_t tid) {
return m_thread_list.SetCurrentThread(tid);
}
bool MachProcess::GetThreadStoppedReason(nub_thread_t tid,
struct DNBThreadStopInfo *stop_info) {
if (m_thread_list.GetThreadStoppedReason(tid, stop_info)) {
if (m_did_exec)
stop_info->reason = eStopTypeExec;
return true;
}
return false;
}
void MachProcess::DumpThreadStoppedReason(nub_thread_t tid) const {
return m_thread_list.DumpThreadStoppedReason(tid);
}
const char *MachProcess::GetThreadInfo(nub_thread_t tid) const {
return m_thread_list.GetThreadInfo(tid);
}
uint32_t MachProcess::GetCPUType() {
if (m_cpu_type == 0 && m_pid != 0)
m_cpu_type = MachProcess::GetCPUTypeForLocalProcess(m_pid);
return m_cpu_type;
}
const DNBRegisterSetInfo *
MachProcess::GetRegisterSetInfo(nub_thread_t tid,
nub_size_t *num_reg_sets) const {
MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
if (thread_sp) {
DNBArchProtocol *arch = thread_sp->GetArchProtocol();
if (arch)
return arch->GetRegisterSetInfo(num_reg_sets);
}
*num_reg_sets = 0;
return NULL;
}
bool MachProcess::GetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
DNBRegisterValue *value) const {
return m_thread_list.GetRegisterValue(tid, set, reg, value);
}
bool MachProcess::SetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
const DNBRegisterValue *value) const {
return m_thread_list.SetRegisterValue(tid, set, reg, value);
}
void MachProcess::SetState(nub_state_t new_state) {
// If any other threads access this we will need a mutex for it
uint32_t event_mask = 0;
// Scope for mutex locker
{
PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
const nub_state_t old_state = m_state;
if (old_state == eStateExited) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) ignoring new "
"state since current state is exited",
DNBStateAsString(new_state));
} else if (old_state == new_state) {
DNBLogThreadedIf(
LOG_PROCESS,
"MachProcess::SetState(%s) ignoring redundant state change...",
DNBStateAsString(new_state));
} else {
if (NUB_STATE_IS_STOPPED(new_state))
event_mask = eEventProcessStoppedStateChanged;
else
event_mask = eEventProcessRunningStateChanged;
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);
m_state = new_state;
if (new_state == eStateStopped)
m_stop_count++;
}
}
if (event_mask != 0) {
m_events.SetEvents(event_mask);
m_private_events.SetEvents(event_mask);
if (event_mask == eEventProcessStoppedStateChanged)
m_private_events.ResetEvents(eEventProcessRunningStateChanged);
else
m_private_events.ResetEvents(eEventProcessStoppedStateChanged);
// Wait for the event bit to reset if a reset ACK is requested
m_events.WaitForResetAck(event_mask);
}
}
void MachProcess::Clear(bool detaching) {
// Clear any cached thread list while the pid and task are still valid
m_task.Clear();
// Now clear out all member variables
m_pid = INVALID_NUB_PROCESS;
if (!detaching)
CloseChildFileDescriptors();
m_path.clear();
m_args.clear();
SetState(eStateUnloaded);
m_flags = eMachProcessFlagsNone;
m_stop_count = 0;
m_thread_list.Clear();
{
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
m_exception_messages.clear();
}
m_activities.Clear();
if (m_profile_thread) {
pthread_join(m_profile_thread, NULL);
m_profile_thread = NULL;
}
}
bool MachProcess::StartSTDIOThread() {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
// Create the thread that watches for the child STDIO
return ::pthread_create(&m_stdio_thread, NULL, MachProcess::STDIOThread,
this) == 0;
}
void MachProcess::SetEnableAsyncProfiling(bool enable, uint64_t interval_usec,
DNBProfileDataScanType scan_type) {
m_profile_enabled = enable;
m_profile_interval_usec = static_cast<useconds_t>(interval_usec);
m_profile_scan_type = scan_type;
if (m_profile_enabled && (m_profile_thread == NULL)) {
StartProfileThread();
} else if (!m_profile_enabled && m_profile_thread) {
pthread_join(m_profile_thread, NULL);
m_profile_thread = NULL;
}
}
bool MachProcess::StartProfileThread() {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
// Create the thread that profiles the inferior and reports back if enabled
return ::pthread_create(&m_profile_thread, NULL, MachProcess::ProfileThread,
this) == 0;
}
nub_addr_t MachProcess::LookupSymbol(const char *name, const char *shlib) {
if (m_name_to_addr_callback != NULL && name && name[0])
return m_name_to_addr_callback(ProcessID(), name, shlib,
m_name_to_addr_baton);
return INVALID_NUB_ADDRESS;
}
bool MachProcess::Resume(const DNBThreadResumeActions &thread_actions) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Resume ()");
nub_state_t state = GetState();
if (CanResume(state)) {
m_thread_actions = thread_actions;
PrivateResume();
return true;
} else if (state == eStateRunning) {
DNBLog("Resume() - task 0x%x is already running, ignoring...",
m_task.TaskPort());
return true;
}
DNBLog("Resume() - task 0x%x has state %s, can't continue...",
m_task.TaskPort(), DNBStateAsString(state));
return false;
}
bool MachProcess::Kill(const struct timespec *timeout_abstime) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill ()");
nub_state_t state = DoSIGSTOP(true, false, NULL);
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() state = %s",
DNBStateAsString(state));
errno = 0;
DNBLog("Sending ptrace PT_KILL to terminate inferior process.");
::ptrace(PT_KILL, m_pid, 0, 0);
DNBError err;
err.SetErrorToErrno();
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() ::ptrace "
"(PT_KILL, pid=%u, 0, 0) => 0x%8.8x (%s)",
m_pid, err.Status(), err.AsString());
m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
PrivateResume();
// Try and reap the process without touching our m_events since
// we want the code above this to still get the eStateExited event
const uint32_t reap_timeout_usec =
1000000; // Wait 1 second and try to reap the process
const uint32_t reap_interval_usec = 10000; //
uint32_t reap_time_elapsed;
for (reap_time_elapsed = 0; reap_time_elapsed < reap_timeout_usec;
reap_time_elapsed += reap_interval_usec) {
if (GetState() == eStateExited)
break;
usleep(reap_interval_usec);
}
DNBLog("Waited %u ms for process to be reaped (state = %s)",
reap_time_elapsed / 1000, DNBStateAsString(GetState()));
return true;
}
bool MachProcess::Interrupt() {
nub_state_t state = GetState();
if (IsRunning(state)) {
if (m_sent_interrupt_signo == 0) {
m_sent_interrupt_signo = SIGSTOP;
if (Signal(m_sent_interrupt_signo)) {
DNBLogThreadedIf(
LOG_PROCESS,
"MachProcess::Interrupt() - sent %i signal to interrupt process",
m_sent_interrupt_signo);
return true;
} else {
m_sent_interrupt_signo = 0;
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - failed to "
"send %i signal to interrupt process",
m_sent_interrupt_signo);
}
} else {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - previously "
"sent an interrupt signal %i that hasn't "
"been received yet, interrupt aborted",
m_sent_interrupt_signo);
}
} else {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - process already "
"stopped, no interrupt sent");
}
return false;
}
bool MachProcess::Signal(int signal, const struct timespec *timeout_abstime) {
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::Signal (signal = %d, timeout = %p)", signal,
reinterpret_cast<const void *>(timeout_abstime));
nub_state_t state = GetState();
if (::kill(ProcessID(), signal) == 0) {
// If we were running and we have a timeout, wait for the signal to stop
if (IsRunning(state) && timeout_abstime) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout "
"= %p) waiting for signal to stop "
"process...",
signal, reinterpret_cast<const void *>(timeout_abstime));
m_private_events.WaitForSetEvents(eEventProcessStoppedStateChanged,
timeout_abstime);
state = GetState();
DNBLogThreadedIf(
LOG_PROCESS,
"MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal,
reinterpret_cast<const void *>(timeout_abstime),
DNBStateAsString(state));
return !IsRunning(state);
}
DNBLogThreadedIf(
LOG_PROCESS,
"MachProcess::Signal (signal = %d, timeout = %p) not waiting...",
signal, reinterpret_cast<const void *>(timeout_abstime));
return true;
}
DNBError err(errno, DNBError::POSIX);
err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal);
return false;
}
bool MachProcess::SendEvent(const char *event, DNBError &send_err) {
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::SendEvent (event = %s) to pid: %d", event,
m_pid);
if (m_pid == INVALID_NUB_PROCESS)
return false;
// FIXME: Shouldn't we use the launch flavor we were started with?
#if defined(WITH_FBS) || defined(WITH_BKS)
return BoardServiceSendEvent(event, send_err);
#endif
return true;
}
nub_state_t MachProcess::DoSIGSTOP(bool clear_bps_and_wps, bool allow_running,
uint32_t *thread_idx_ptr) {
nub_state_t state = GetState();
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s",
DNBStateAsString(state));
if (!IsRunning(state)) {
if (clear_bps_and_wps) {
DisableAllBreakpoints(true);
DisableAllWatchpoints(true);
clear_bps_and_wps = false;
}
// If we already have a thread stopped due to a SIGSTOP, we don't have
// to do anything...
uint32_t thread_idx =
m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
if (thread_idx_ptr)
*thread_idx_ptr = thread_idx;
if (thread_idx != UINT32_MAX)
return GetState();
// No threads were stopped with a SIGSTOP, we need to run and halt the
// process with a signal
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::DoSIGSTOP() state = %s -- resuming process",
DNBStateAsString(state));
if (allow_running)
m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
else
m_thread_actions = DNBThreadResumeActions(eStateSuspended, 0);
PrivateResume();
// Reset the event that says we were indeed running
m_events.ResetEvents(eEventProcessRunningStateChanged);
state = GetState();
}
// We need to be stopped in order to be able to detach, so we need
// to send ourselves a SIGSTOP
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::DoSIGSTOP() state = %s -- sending SIGSTOP",
DNBStateAsString(state));
struct timespec sigstop_timeout;
DNBTimer::OffsetTimeOfDay(&sigstop_timeout, 2, 0);
Signal(SIGSTOP, &sigstop_timeout);
if (clear_bps_and_wps) {
DisableAllBreakpoints(true);
DisableAllWatchpoints(true);
// clear_bps_and_wps = false;
}
uint32_t thread_idx =
m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
if (thread_idx_ptr)
*thread_idx_ptr = thread_idx;
return GetState();
}
bool MachProcess::Detach() {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach()");
uint32_t thread_idx = UINT32_MAX;
nub_state_t state = DoSIGSTOP(true, true, &thread_idx);
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach() DoSIGSTOP() returned %s",
DNBStateAsString(state));
{
m_thread_actions.Clear();
m_activities.Clear();
DNBThreadResumeAction thread_action;
thread_action.tid = m_thread_list.ThreadIDAtIndex(thread_idx);
thread_action.state = eStateRunning;
thread_action.signal = -1;
thread_action.addr = INVALID_NUB_ADDRESS;
m_thread_actions.Append(thread_action);
m_thread_actions.SetDefaultThreadActionIfNeeded(eStateRunning, 0);
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
ReplyToAllExceptions();
}
m_task.ShutDownExcecptionThread();
// Detach from our process
errno = 0;
nub_process_t pid = m_pid;
int ret = ::ptrace(PT_DETACH, pid, (caddr_t)1, 0);
DNBError err(errno, DNBError::POSIX);
if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
// Resume our task
m_task.Resume();
// NULL our task out as we have already restored all exception ports
m_task.Clear();
// Clear out any notion of the process we once were
const bool detaching = true;
Clear(detaching);
SetState(eStateDetached);
return true;
}
//----------------------------------------------------------------------
// ReadMemory from the MachProcess level will always remove any software
// breakpoints from the memory buffer before returning. If you wish to
// read memory and see those traps, read from the MachTask
// (m_task.ReadMemory()) as that version will give you what is actually
// in inferior memory.
//----------------------------------------------------------------------
nub_size_t MachProcess::ReadMemory(nub_addr_t addr, nub_size_t size,
void *buf) {
// We need to remove any current software traps (enabled software
// breakpoints) that we may have placed in our tasks memory.
// First just read the memory as is
nub_size_t bytes_read = m_task.ReadMemory(addr, size, buf);
// Then place any opcodes that fall into this range back into the buffer
// before we return this to callers.
if (bytes_read > 0)
m_breakpoints.RemoveTrapsFromBuffer(addr, bytes_read, buf);
return bytes_read;
}
//----------------------------------------------------------------------
// WriteMemory from the MachProcess level will always write memory around
// any software breakpoints. Any software breakpoints will have their
// opcodes modified if they are enabled. Any memory that doesn't overlap
// with software breakpoints will be written to. If you wish to write to
// inferior memory without this interference, then write to the MachTask
// (m_task.WriteMemory()) as that version will always modify inferior
// memory.
//----------------------------------------------------------------------
nub_size_t MachProcess::WriteMemory(nub_addr_t addr, nub_size_t size,
const void *buf) {
// We need to write any data that would go where any current software traps
// (enabled software breakpoints) any software traps (breakpoints) that we
// may have placed in our tasks memory.
std::vector<DNBBreakpoint *> bps;
const size_t num_bps =
m_breakpoints.FindBreakpointsThatOverlapRange(addr, size, bps);
if (num_bps == 0)
return m_task.WriteMemory(addr, size, buf);
nub_size_t bytes_written = 0;
nub_addr_t intersect_addr;
nub_size_t intersect_size;
nub_size_t opcode_offset;
const uint8_t *ubuf = (const uint8_t *)buf;
for (size_t i = 0; i < num_bps; ++i) {
DNBBreakpoint *bp = bps[i];
const bool intersects = bp->IntersectsRange(
addr, size, &intersect_addr, &intersect_size, &opcode_offset);
UNUSED_IF_ASSERT_DISABLED(intersects);
assert(intersects);
assert(addr <= intersect_addr && intersect_addr < addr + size);
assert(addr < intersect_addr + intersect_size &&
intersect_addr + intersect_size <= addr + size);
assert(opcode_offset + intersect_size <= bp->ByteSize());
// Check for bytes before this breakpoint
const nub_addr_t curr_addr = addr + bytes_written;
if (intersect_addr > curr_addr) {
// There are some bytes before this breakpoint that we need to
// just write to memory
nub_size_t curr_size = intersect_addr - curr_addr;
nub_size_t curr_bytes_written =
m_task.WriteMemory(curr_addr, curr_size, ubuf + bytes_written);
bytes_written += curr_bytes_written;
if (curr_bytes_written != curr_size) {
// We weren't able to write all of the requested bytes, we
// are done looping and will return the number of bytes that
// we have written so far.
break;
}
}
// Now write any bytes that would cover up any software breakpoints
// directly into the breakpoint opcode buffer
::memcpy(bp->SavedOpcodeBytes() + opcode_offset, ubuf + bytes_written,
intersect_size);
bytes_written += intersect_size;
}
// Write any remaining bytes after the last breakpoint if we have any left
if (bytes_written < size)
bytes_written += m_task.WriteMemory(
addr + bytes_written, size - bytes_written, ubuf + bytes_written);
return bytes_written;
}
void MachProcess::ReplyToAllExceptions() {
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
if (m_exception_messages.empty() == false) {
MachException::Message::iterator pos;
MachException::Message::iterator begin = m_exception_messages.begin();
MachException::Message::iterator end = m_exception_messages.end();
for (pos = begin; pos != end; ++pos) {
DNBLogThreadedIf(LOG_EXCEPTIONS, "Replying to exception %u...",
(uint32_t)std::distance(begin, pos));
int thread_reply_signal = 0;
nub_thread_t tid =
m_thread_list.GetThreadIDByMachPortNumber(pos->state.thread_port);
const DNBThreadResumeAction *action = NULL;
if (tid != INVALID_NUB_THREAD) {
action = m_thread_actions.GetActionForThread(tid, false);
}
if (action) {
thread_reply_signal = action->signal;
if (thread_reply_signal)
m_thread_actions.SetSignalHandledForThread(tid);
}
DNBError err(pos->Reply(this, thread_reply_signal));
if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
err.LogThreadedIfError("Error replying to exception");
}
// Erase all exception message as we should have used and replied
// to them all already.
m_exception_messages.clear();
}
}
void MachProcess::PrivateResume() {
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
m_auto_resume_signo = m_sent_interrupt_signo;
if (m_auto_resume_signo)
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::PrivateResume() - task 0x%x "
"resuming (with unhandled interrupt signal "
"%i)...",
m_task.TaskPort(), m_auto_resume_signo);
else
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::PrivateResume() - task 0x%x resuming...",
m_task.TaskPort());
ReplyToAllExceptions();
// bool stepOverBreakInstruction = step;
// Let the thread prepare to resume and see if any threads want us to
// step over a breakpoint instruction (ProcessWillResume will modify
// the value of stepOverBreakInstruction).
m_thread_list.ProcessWillResume(this, m_thread_actions);
// Set our state accordingly
if (m_thread_actions.NumActionsWithState(eStateStepping))
SetState(eStateStepping);
else
SetState(eStateRunning);
// Now resume our task.
m_task.Resume();
}
DNBBreakpoint *MachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length,
bool hardware) {
DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
"0x%8.8llx, length = %llu, hardware = %i)",
(uint64_t)addr, (uint64_t)length, hardware);
DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
if (bp)
bp->Retain();
else
bp = m_breakpoints.Add(addr, length, hardware);
if (EnableBreakpoint(addr)) {
DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
"0x%8.8llx, length = %llu) => %p",
(uint64_t)addr, (uint64_t)length,
reinterpret_cast<void *>(bp));
return bp;
} else if (bp->Release() == 0) {
m_breakpoints.Remove(addr);
}
// We failed to enable the breakpoint
return NULL;
}
DNBBreakpoint *MachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length,
uint32_t watch_flags,
bool hardware) {
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);
DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
// since the Z packets only send an address, we can only have one watchpoint
// at
// an address. If there is already one, we must refuse to create another
// watchpoint
if (wp)
return NULL;
wp = m_watchpoints.Add(addr, length, hardware);
wp->SetIsWatchpoint(watch_flags);
if (EnableWatchpoint(addr)) {
DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
"0x%8.8llx, length = %llu) => %p",
(uint64_t)addr, (uint64_t)length,
reinterpret_cast<void *>(wp));
return wp;
} else {
DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
"0x%8.8llx, length = %llu) => FAILED",
(uint64_t)addr, (uint64_t)length);
m_watchpoints.Remove(addr);
}
// We failed to enable the watchpoint
return NULL;
}
void MachProcess::DisableAllBreakpoints(bool remove) {
DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::%s (remove = %d )",
__FUNCTION__, remove);
m_breakpoints.DisableAllBreakpoints(this);
if (remove)
m_breakpoints.RemoveDisabled();
}
void MachProcess::DisableAllWatchpoints(bool remove) {
DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s (remove = %d )",
__FUNCTION__, remove);
m_watchpoints.DisableAllWatchpoints(this);
if (remove)
m_watchpoints.RemoveDisabled();
}
bool MachProcess::DisableBreakpoint(nub_addr_t addr, bool remove) {
DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
if (bp) {
// After "exec" we might end up with a bunch of breakpoints that were
// disabled
// manually, just ignore them
if (!bp->IsEnabled()) {
// Breakpoint might have been disabled by an exec
if (remove && bp->Release() == 0) {
m_thread_list.NotifyBreakpointChanged(bp);
m_breakpoints.Remove(addr);
}
return true;
}
// We have multiple references to this breakpoint, decrement the ref count
// and if it isn't zero, then return true;
if (remove && bp->Release() > 0)
return true;
DNBLogThreadedIf(
LOG_BREAKPOINTS | LOG_VERBOSE,
"MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d )",
(uint64_t)addr, remove);
if (bp->IsHardware()) {
bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint(bp);
if (hw_disable_result == true) {
bp->SetEnabled(false);
// Let the thread list know that a breakpoint has been modified
if (remove) {
m_thread_list.NotifyBreakpointChanged(bp);
m_breakpoints.Remove(addr);
}
DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( "
"addr = 0x%8.8llx, remove = %d ) "
"(hardware) => success",
(uint64_t)addr, remove);
return true;
}
return false;
}
const nub_size_t break_op_size = bp->ByteSize();
assert(break_op_size > 0);
const uint8_t *const break_op =
DNBArchProtocol::GetBreakpointOpcode(bp->ByteSize());
if (break_op_size > 0) {
// Clear a software breakpoint instruction
uint8_t curr_break_op[break_op_size];
bool break_op_found = false;
// Read the breakpoint opcode
if (m_task.ReadMemory(addr, break_op_size, curr_break_op) ==
break_op_size) {
bool verify = false;
if (bp->IsEnabled()) {
// Make sure a breakpoint opcode exists at this address
if (memcmp(curr_break_op, break_op, break_op_size) == 0) {
break_op_found = true;
// We found a valid breakpoint opcode at this address, now restore
// the saved opcode.
if (m_task.WriteMemory(addr, break_op_size,
bp->SavedOpcodeBytes()) == break_op_size) {
verify = true;
} else {
DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
"remove = %d ) memory write failed when restoring "
"original opcode",
(uint64_t)addr, remove);
}
} else {
DNBLogWarning("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
"remove = %d ) expected a breakpoint opcode but "
"didn't find one.",
(uint64_t)addr, remove);
// Set verify to true and so we can check if the original opcode has
// already been restored
verify = true;
}
} else {
DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE,
"MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
"remove = %d ) is not enabled",
(uint64_t)addr, remove);
// Set verify to true and so we can check if the original opcode is
// there
verify = true;
}
if (verify) {
uint8_t verify_opcode[break_op_size];
// Verify that our original opcode made it back to the inferior
if (m_task.ReadMemory(addr, break_op_size, verify_opcode) ==
break_op_size) {
// compare the memory we just read with the original opcode
if (memcmp(bp->SavedOpcodeBytes(), verify_opcode, break_op_size) ==
0) {
// SUCCESS
bp->SetEnabled(false);
// Let the thread list know that a breakpoint has been modified
if (remove && bp->Release() == 0) {
m_thread_list.NotifyBreakpointChanged(bp);
m_breakpoints.Remove(addr);
}
DNBLogThreadedIf(LOG_BREAKPOINTS,
"MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) => success",
(uint64_t)addr, remove);
return true;
} else {
if (break_op_found)
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : failed to restore "
"original opcode",
(uint64_t)addr, remove);
else
DNBLogError("MachProcess::DisableBreakpoint ( addr = "
"0x%8.8llx, remove = %d ) : opcode changed",
(uint64_t)addr, remove);
}
} else {
DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable "
"breakpoint 0x%8.8llx",
(uint64_t)addr);
}
}
} else {
DNBLogWarning("MachProcess::DisableBreakpoint: unable to read memory "
"at 0x%8.8llx",
(uint64_t)addr);
}
}
} else {
DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = "
"%d ) invalid breakpoint address",
(uint64_t)addr, remove);
}
return false;
}
bool MachProcess::DisableWatchpoint(nub_addr_t addr, bool remove) {
DNBLogThreadedIf(LOG_WATCHPOINTS,
"MachProcess::%s(addr = 0x%8.8llx, remove = %d)",
__FUNCTION__, (uint64_t)addr, remove);
DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
if (wp) {
// If we have multiple references to a watchpoint, removing the watchpoint
// shouldn't clear it
if (remove && wp->Release() > 0)
return true;
nub_addr_t addr = wp->Address();
DNBLogThreadedIf(
LOG_WATCHPOINTS,
"MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = %d )",
(uint64_t)addr, remove);
if (wp->IsHardware()) {
bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint(wp);
if (hw_disable_result == true) {
wp->SetEnabled(false);
if (remove)
m_watchpoints.Remove(addr);
DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::Disablewatchpoint ( "
"addr = 0x%8.8llx, remove = %d ) "
"(hardware) => success",
(uint64_t)addr, remove);
return true;
}
}
// TODO: clear software watchpoints if we implement them
} else {
DNBLogError("MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = "
"%d ) invalid watchpoint ID",
(uint64_t)addr, remove);
}
return false;
}
uint32_t MachProcess::GetNumSupportedHardwareWatchpoints() const {
return m_thread_list.NumSupportedHardwareWatchpoints();
}
bool MachProcess::EnableBreakpoint(nub_addr_t addr) {
DNBLogThreadedIf(LOG_BREAKPOINTS,
"MachProcess::EnableBreakpoint ( addr = 0x%8.8llx )",
(uint64_t)addr);
DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
if (bp) {
if (bp->IsEnabled()) {
DNBLogWarning("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
"breakpoint already enabled.",
(uint64_t)addr);
return true;
} else {
if (bp->HardwarePreferred()) {
bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp));
if (bp->IsHardware()) {
bp->SetEnabled(true);
return true;
}
}
const nub_size_t break_op_size = bp->ByteSize();
assert(break_op_size != 0);
const uint8_t *const break_op =
DNBArchProtocol::GetBreakpointOpcode(break_op_size);
if (break_op_size > 0) {
// Save the original opcode by reading it
if (m_task.ReadMemory(addr, break_op_size, bp->SavedOpcodeBytes()) ==
break_op_size) {
// Write a software breakpoint in place of the original opcode
if (m_task.WriteMemory(addr, break_op_size, break_op) ==
break_op_size) {
uint8_t verify_break_op[4];
if (m_task.ReadMemory(addr, break_op_size, verify_break_op) ==
break_op_size) {
if (memcmp(break_op, verify_break_op, break_op_size) == 0) {
bp->SetEnabled(true);
// Let the thread list know that a breakpoint has been modified
m_thread_list.NotifyBreakpointChanged(bp);
DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::"
"EnableBreakpoint ( addr = "
"0x%8.8llx ) : SUCCESS.",
(uint64_t)addr);
return true;
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx "
"): breakpoint opcode verification failed.",
(uint64_t)addr);
}
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
"unable to read memory to verify breakpoint opcode.",
(uint64_t)addr);
}
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
"unable to write breakpoint opcode to memory.",
(uint64_t)addr);
}
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
"unable to read memory at breakpoint address.",
(uint64_t)addr);
}
} else {
DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ) no "
"software breakpoint opcode for current architecture.",
(uint64_t)addr);
}
}
}
return false;
}
bool MachProcess::EnableWatchpoint(nub_addr_t addr) {
DNBLogThreadedIf(LOG_WATCHPOINTS,
"MachProcess::EnableWatchpoint(addr = 0x%8.8llx)",
(uint64_t)addr);
DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
if (wp) {
nub_addr_t addr = wp->Address();
if (wp->IsEnabled()) {
DNBLogWarning("MachProcess::EnableWatchpoint(addr = 0x%8.8llx): "
"watchpoint already enabled.",
(uint64_t)addr);
return true;
} else {
// Currently only try and set hardware watchpoints.
wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp));
if (wp->IsHardware()) {
wp->SetEnabled(true);
return true;
}
// TODO: Add software watchpoints by doing page protection tricks.
}
}
return false;
}
// Called by the exception thread when an exception has been received from
// our process. The exception message is completely filled and the exception
// data has already been copied.
void MachProcess::ExceptionMessageReceived(
const MachException::Message &exceptionMessage) {
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
if (m_exception_messages.empty())
m_task.Suspend();
DNBLogThreadedIf(LOG_EXCEPTIONS, "MachProcess::ExceptionMessageReceived ( )");
// Use a locker to automatically unlock our mutex in case of exceptions
// Add the exception to our internal exception stack
m_exception_messages.push_back(exceptionMessage);
}
task_t MachProcess::ExceptionMessageBundleComplete() {
// We have a complete bundle of exceptions for our child process.
PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
DNBLogThreadedIf(LOG_EXCEPTIONS, "%s: %llu exception messages.",
__PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
bool auto_resume = false;
if (!m_exception_messages.empty()) {
m_did_exec = false;
// First check for any SIGTRAP and make sure we didn't exec
const task_t task = m_task.TaskPort();
size_t i;
if (m_pid != 0) {
bool received_interrupt = false;
uint32_t num_task_exceptions = 0;
for (i = 0; i < m_exception_messages.size(); ++i) {
if (m_exception_messages[i].state.task_port == task) {
++num_task_exceptions;
const int signo = m_exception_messages[i].state.SoftSignal();
if (signo == SIGTRAP) {
// SIGTRAP could mean that we exec'ed. We need to check the
// dyld all_image_infos.infoArray to see if it is NULL and if
// so, say that we exec'ed.
const nub_addr_t aii_addr = GetDYLDAllImageInfosAddress();
if (aii_addr != INVALID_NUB_ADDRESS) {
const nub_addr_t info_array_count_addr = aii_addr + 4;
uint32_t info_array_count = 0;
if (m_task.ReadMemory(info_array_count_addr, 4,
&info_array_count) == 4) {
if (info_array_count == 0) {
m_did_exec = true;
// Force the task port to update itself in case the task port
// changed after exec
DNBError err;
const task_t old_task = m_task.TaskPort();
const task_t new_task =
m_task.TaskPortForProcessID(err, true);
if (old_task != new_task)
DNBLogThreadedIf(
LOG_PROCESS,
"exec: task changed from 0x%4.4x to 0x%4.4x", old_task,
new_task);
}
} else {
DNBLog("error: failed to read all_image_infos.infoArrayCount "
"from 0x%8.8llx",
(uint64_t)info_array_count_addr);
}
}
break;
} else if (m_sent_interrupt_signo != 0 &&
signo == m_sent_interrupt_signo) {
received_interrupt = true;
}
}
}
if (m_did_exec) {
cpu_type_t process_cpu_type =
MachProcess::GetCPUTypeForLocalProcess(m_pid);
if (m_cpu_type != process_cpu_type) {
DNBLog("arch changed from 0x%8.8x to 0x%8.8x", m_cpu_type,
process_cpu_type);
m_cpu_type = process_cpu_type;
DNBArchProtocol::SetArchitecture(process_cpu_type);
}
m_thread_list.Clear();
m_activities.Clear();
m_breakpoints.DisableAll();
}
if (m_sent_interrupt_signo != 0) {
if (received_interrupt) {
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::ExceptionMessageBundleComplete(): "
"process successfully interrupted with signal %i",
m_sent_interrupt_signo);
// Mark that we received the interrupt signal
m_sent_interrupt_signo = 0;
// Not check if we had a case where:
// 1 - We called MachProcess::Interrupt() but we stopped for another
// reason
// 2 - We called MachProcess::Resume() (but still haven't gotten the
// interrupt signal)
// 3 - We are now incorrectly stopped because we are handling the
// interrupt signal we missed
// 4 - We might need to resume if we stopped only with the interrupt
// signal that we never handled
if (m_auto_resume_signo != 0) {
// Only auto_resume if we stopped with _only_ the interrupt signal
if (num_task_exceptions == 1) {
auto_resume = true;
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
"ExceptionMessageBundleComplete(): "
"auto resuming due to unhandled "
"interrupt signal %i",
m_auto_resume_signo);
}
m_auto_resume_signo = 0;
}
} else {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
"ExceptionMessageBundleComplete(): "
"didn't get signal %i after "
"MachProcess::Interrupt()",
m_sent_interrupt_signo);
}
}
}
// Let all threads recover from stopping and do any clean up based
// on the previous thread state (if any).
m_thread_list.ProcessDidStop(this);
m_activities.Clear();
// Let each thread know of any exceptions
for (i = 0; i < m_exception_messages.size(); ++i) {
// Let the thread list figure use the MachProcess to forward all
// exceptions
// on down to each thread.
if (m_exception_messages[i].state.task_port == task)
m_thread_list.NotifyException(m_exception_messages[i].state);
if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
m_exception_messages[i].Dump();
}
if (DNBLogCheckLogBit(LOG_THREAD))
m_thread_list.Dump();
bool step_more = false;
if (m_thread_list.ShouldStop(step_more) && auto_resume == false) {
// Wait for the eEventProcessRunningStateChanged event to be reset
// before changing state to stopped to avoid race condition with
// very fast start/stops
struct timespec timeout;
// DNBTimer::OffsetTimeOfDay(&timeout, 0, 250 * 1000); // Wait for 250
// ms
DNBTimer::OffsetTimeOfDay(&timeout, 1, 0); // Wait for 250 ms
m_events.WaitForEventsToReset(eEventProcessRunningStateChanged, &timeout);
SetState(eStateStopped);
} else {
// Resume without checking our current state.
PrivateResume();
}
} else {
DNBLogThreadedIf(
LOG_EXCEPTIONS, "%s empty exception messages bundle (%llu exceptions).",
__PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
}
return m_task.TaskPort();
}
nub_size_t
MachProcess::CopyImageInfos(struct DNBExecutableImageInfo **image_infos,
bool only_changed) {
if (m_image_infos_callback != NULL)
return m_image_infos_callback(ProcessID(), image_infos, only_changed,
m_image_infos_baton);
return 0;
}
void MachProcess::SharedLibrariesUpdated() {
uint32_t event_bits = eEventSharedLibsStateChange;
// Set the shared library event bit to let clients know of shared library
// changes
m_events.SetEvents(event_bits);
// Wait for the event bit to reset if a reset ACK is requested
m_events.WaitForResetAck(event_bits);
}
void MachProcess::SetExitInfo(const char *info) {
if (info && info[0]) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(\"%s\")", __FUNCTION__,
info);
m_exit_info.assign(info);
} else {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(NULL)", __FUNCTION__);
m_exit_info.clear();
}
}
void MachProcess::AppendSTDOUT(char *s, size_t len) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (<%llu> %s) ...", __FUNCTION__,
(uint64_t)len, s);
PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
m_stdout_data.append(s, len);
m_events.SetEvents(eEventStdioAvailable);
// Wait for the event bit to reset if a reset ACK is requested
m_events.WaitForResetAck(eEventStdioAvailable);
}
size_t MachProcess::GetAvailableSTDOUT(char *buf, size_t buf_size) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
reinterpret_cast<void *>(buf), (uint64_t)buf_size);
PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
size_t bytes_available = m_stdout_data.size();
if (bytes_available > 0) {
if (bytes_available > buf_size) {
memcpy(buf, m_stdout_data.data(), buf_size);
m_stdout_data.erase(0, buf_size);
bytes_available = buf_size;
} else {
memcpy(buf, m_stdout_data.data(), bytes_available);
m_stdout_data.clear();
}
}
return bytes_available;
}
nub_addr_t MachProcess::GetDYLDAllImageInfosAddress() {
DNBError err;
return m_task.GetDYLDAllImageInfosAddress(err);
}
size_t MachProcess::GetAvailableSTDERR(char *buf, size_t buf_size) { return 0; }
void *MachProcess::STDIOThread(void *arg) {
MachProcess *proc = (MachProcess *)arg;
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::%s ( arg = %p ) thread starting...",
__FUNCTION__, arg);
#if defined(__APPLE__)
pthread_setname_np("stdio monitoring thread");
#endif
// We start use a base and more options so we can control if we
// are currently using a timeout on the mach_msg. We do this to get a
// bunch of related exceptions on our exception port so we can process
// then together. When we have multiple threads, we can get an exception
// per thread and they will come in consecutively. The main thread loop
// will start by calling mach_msg to without having the MACH_RCV_TIMEOUT
// flag set in the options, so we will wait forever for an exception on
// our exception port. After we get one exception, we then will use the
// MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
// exceptions for our process. After we have received the last pending
// exception, we will get a timeout which enables us to then notify
// our main thread that we have an exception bundle available. We then wait
// for the main thread to tell this exception thread to start trying to get
// exceptions messages again and we start again with a mach_msg read with
// infinite timeout.
DNBError err;
int stdout_fd = proc->GetStdoutFileDescriptor();
int stderr_fd = proc->GetStderrFileDescriptor();
if (stdout_fd == stderr_fd)
stderr_fd = -1;
while (stdout_fd >= 0 || stderr_fd >= 0) {
::pthread_testcancel();
fd_set read_fds;
FD_ZERO(&read_fds);
if (stdout_fd >= 0)
FD_SET(stdout_fd, &read_fds);
if (stderr_fd >= 0)
FD_SET(stderr_fd, &read_fds);
int nfds = std::max<int>(stdout_fd, stderr_fd) + 1;
int num_set_fds = select(nfds, &read_fds, NULL, NULL, NULL);
DNBLogThreadedIf(LOG_PROCESS,
"select (nfds, &read_fds, NULL, NULL, NULL) => %d",
num_set_fds);
if (num_set_fds < 0) {
int select_errno = errno;
if (DNBLogCheckLogBit(LOG_PROCESS)) {
err.SetError(select_errno, DNBError::POSIX);
err.LogThreadedIfError(
"select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds);
}
switch (select_errno) {
case EAGAIN: // The kernel was (perhaps temporarily) unable to allocate
// the requested number of file descriptors, or we have
// non-blocking IO
break;
case EBADF: // One of the descriptor sets specified an invalid descriptor.
return NULL;
break;
case EINTR: // A signal was delivered before the time limit expired and
// before any of the selected events occurred.
case EINVAL: // The specified time limit is invalid. One of its components
// is negative or too large.
default: // Other unknown error
break;
}
} else if (num_set_fds == 0) {
} else {
char s[1024];
s[sizeof(s) - 1] = '\0'; // Ensure we have NULL termination
ssize_t bytes_read = 0;
if (stdout_fd >= 0 && FD_ISSET(stdout_fd, &read_fds)) {
do {
bytes_read = ::read(stdout_fd, s, sizeof(s) - 1);
if (bytes_read < 0) {
int read_errno = errno;
DNBLogThreadedIf(LOG_PROCESS,
"read (stdout_fd, ) => %zd errno: %d (%s)",
bytes_read, read_errno, strerror(read_errno));
} else if (bytes_read == 0) {
// EOF...
DNBLogThreadedIf(
LOG_PROCESS,
"read (stdout_fd, ) => %zd (reached EOF for child STDOUT)",
bytes_read);
stdout_fd = -1;
} else if (bytes_read > 0) {
proc->AppendSTDOUT(s, bytes_read);
}
} while (bytes_read > 0);
}
if (stderr_fd >= 0 && FD_ISSET(stderr_fd, &read_fds)) {
do {
bytes_read = ::read(stderr_fd, s, sizeof(s) - 1);
if (bytes_read < 0) {
int read_errno = errno;
DNBLogThreadedIf(LOG_PROCESS,
"read (stderr_fd, ) => %zd errno: %d (%s)",
bytes_read, read_errno, strerror(read_errno));
} else if (bytes_read == 0) {
// EOF...
DNBLogThreadedIf(
LOG_PROCESS,
"read (stderr_fd, ) => %zd (reached EOF for child STDERR)",
bytes_read);
stderr_fd = -1;
} else if (bytes_read > 0) {
proc->AppendSTDOUT(s, bytes_read);
}
} while (bytes_read > 0);
}
}
}
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%p): thread exiting...",
__FUNCTION__, arg);
return NULL;
}
void MachProcess::SignalAsyncProfileData(const char *info) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%s) ...", __FUNCTION__, info);
PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
m_profile_data.push_back(info);
m_events.SetEvents(eEventProfileDataAvailable);
// Wait for the event bit to reset if a reset ACK is requested
m_events.WaitForResetAck(eEventProfileDataAvailable);
}
size_t MachProcess::GetAsyncProfileData(char *buf, size_t buf_size) {
DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
reinterpret_cast<void *>(buf), (uint64_t)buf_size);
PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
if (m_profile_data.empty())
return 0;
size_t bytes_available = m_profile_data.front().size();
if (bytes_available > 0) {
if (bytes_available > buf_size) {
memcpy(buf, m_profile_data.front().data(), buf_size);
m_profile_data.front().erase(0, buf_size);
bytes_available = buf_size;
} else {
memcpy(buf, m_profile_data.front().data(), bytes_available);
m_profile_data.erase(m_profile_data.begin());
}
}
return bytes_available;
}
void *MachProcess::ProfileThread(void *arg) {
MachProcess *proc = (MachProcess *)arg;
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::%s ( arg = %p ) thread starting...",
__FUNCTION__, arg);
#if defined(__APPLE__)
pthread_setname_np("performance profiling thread");
#endif
while (proc->IsProfilingEnabled()) {
nub_state_t state = proc->GetState();
if (state == eStateRunning) {
std::string data =
proc->Task().GetProfileData(proc->GetProfileScanType());
if (!data.empty()) {
proc->SignalAsyncProfileData(data.c_str());
}
} else if ((state == eStateUnloaded) || (state == eStateDetached) ||
(state == eStateUnloaded)) {
// Done. Get out of this thread.
break;
}
// A simple way to set up the profile interval. We can also use select() or
// dispatch timer source if necessary.
usleep(proc->ProfileInterval());
}
return NULL;
}
pid_t MachProcess::AttachForDebug(pid_t pid, char *err_str, size_t err_len) {
// Clear out and clean up from any current state
Clear();
if (pid != 0) {
DNBError err;
// Make sure the process exists...
if (::getpgid(pid) < 0) {
err.SetErrorToErrno();
const char *err_cstr = err.AsString();
::snprintf(err_str, err_len, "%s",
err_cstr ? err_cstr : "No such process");
return INVALID_NUB_PROCESS;
}
SetState(eStateAttaching);
m_pid = pid;
// Let ourselves know we are going to be using SBS or BKS if the correct flag
// bit is set...
#if defined(WITH_FBS) || defined(WITH_BKS)
bool found_app_flavor = false;
#endif
#if defined(WITH_FBS)
if (!found_app_flavor && IsFBSProcess(pid)) {
found_app_flavor = true;
m_flags |= eMachProcessFlagsUsingFBS;
}
#elif defined(WITH_BKS)
if (!found_app_flavor && IsBKSProcess(pid)) {
found_app_flavor = true;
m_flags |= eMachProcessFlagsUsingBKS;
}
#elif defined(WITH_SPRINGBOARD)
if (IsSBProcess(pid))
m_flags |= eMachProcessFlagsUsingSBS;
#endif
if (!m_task.StartExceptionThread(err)) {
const char *err_cstr = err.AsString();
::snprintf(err_str, err_len, "%s",
err_cstr ? err_cstr : "unable to start the exception thread");
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
m_pid = INVALID_NUB_PROCESS;
return INVALID_NUB_PROCESS;
}
errno = 0;
if (::ptrace(PT_ATTACHEXC, pid, 0, 0))
err.SetError(errno);
else
err.Clear();
if (err.Success()) {
m_flags |= eMachProcessFlagsAttached;
// Sleep a bit to let the exception get received and set our process
// status
// to stopped.
::usleep(250000);
DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid);
return m_pid;
} else {
::snprintf(err_str, err_len, "%s", err.AsString());
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
}
}
return INVALID_NUB_PROCESS;
}
Genealogy::ThreadActivitySP
MachProcess::GetGenealogyInfoForThread(nub_thread_t tid, bool &timed_out) {
return m_activities.GetGenealogyInfoForThread(m_pid, tid, m_thread_list,
m_task.TaskPort(), timed_out);
}
Genealogy::ProcessExecutableInfoSP
MachProcess::GetGenealogyImageInfo(size_t idx) {
return m_activities.GetProcessExecutableInfosAtIndex(idx);
}
bool MachProcess::GetOSVersionNumbers(uint64_t *major, uint64_t *minor,
uint64_t *patch) {
#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101000)
return false;
#else
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSOperatingSystemVersion vers =
[[NSProcessInfo processInfo] operatingSystemVersion];
if (major)
*major = vers.majorVersion;
if (minor)
*minor = vers.minorVersion;
if (patch)
*patch = vers.patchVersion;
[pool drain];
return true;
#endif
}
// Do the process specific setup for attach. If this returns NULL, then there's
// no
// platform specific stuff to be done to wait for the attach. If you get
// non-null,
// pass that token to the CheckForProcess method, and then to
// CleanupAfterAttach.
// Call PrepareForAttach before attaching to a process that has not yet
// launched
// This returns a token that can be passed to CheckForProcess, and to
// CleanupAfterAttach.
// You should call CleanupAfterAttach to free the token, and do whatever other
// cleanup seems good.
const void *MachProcess::PrepareForAttach(const char *path,
nub_launch_flavor_t launch_flavor,
bool waitfor, DNBError &attach_err) {
#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
// Tell SpringBoard to halt the next launch of this application on startup.
if (!waitfor)
return NULL;
const char *app_ext = strstr(path, ".app");
const bool is_app =
app_ext != NULL && (app_ext[4] == '\0' || app_ext[4] == '/');
if (!is_app) {
DNBLogThreadedIf(
LOG_PROCESS,
"MachProcess::PrepareForAttach(): path '%s' doesn't contain .app, "
"we can't tell springboard to wait for launch...",
path);
return NULL;
}
#if defined(WITH_FBS)
if (launch_flavor == eLaunchFlavorDefault)
launch_flavor = eLaunchFlavorFBS;
if (launch_flavor != eLaunchFlavorFBS)
return NULL;
#elif defined(WITH_BKS)
if (launch_flavor == eLaunchFlavorDefault)
launch_flavor = eLaunchFlavorBKS;
if (launch_flavor != eLaunchFlavorBKS)
return NULL;
#elif defined(WITH_SPRINGBOARD)
if (launch_flavor == eLaunchFlavorDefault)
launch_flavor = eLaunchFlavorSpringBoard;
if (launch_flavor != eLaunchFlavorSpringBoard)
return NULL;
#endif
std::string app_bundle_path(path, app_ext + strlen(".app"));
CFStringRef bundleIDCFStr =
CopyBundleIDForPath(app_bundle_path.c_str(), attach_err);
std::string bundleIDStr;
CFString::UTF8(bundleIDCFStr, bundleIDStr);
DNBLogThreadedIf(LOG_PROCESS,
"CopyBundleIDForPath (%s, err_str) returned @\"%s\"",
app_bundle_path.c_str(), bundleIDStr.c_str());
if (bundleIDCFStr == NULL) {
return NULL;
}
#if defined(WITH_FBS)
if (launch_flavor == eLaunchFlavorFBS) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *stdio_path = nil;
NSFileManager *file_manager = [NSFileManager defaultManager];
const char *null_path = "/dev/null";
stdio_path =
[file_manager stringWithFileSystemRepresentation:null_path
length:strlen(null_path)];
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
NSMutableDictionary *options = [NSMutableDictionary dictionary];
DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
"@\"%s\",options include stdio path: \"%s\", "
"BKSDebugOptionKeyDebugOnNextLaunch & "
"BKSDebugOptionKeyWaitForDebugger )",
bundleIDStr.c_str(), null_path);
[debug_options setObject:stdio_path
forKey:FBSDebugOptionKeyStandardOutPath];
[debug_options setObject:stdio_path
forKey:FBSDebugOptionKeyStandardErrorPath];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:FBSDebugOptionKeyWaitForDebugger];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:FBSDebugOptionKeyDebugOnNextLaunch];
[options setObject:debug_options
forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
FBSSystemService *system_service = [[FBSSystemService alloc] init];
mach_port_t client_port = [system_service createClientPort];
__block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block FBSOpenApplicationErrorCode attach_error_code =
FBSOpenApplicationErrorCodeNone;
NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
[system_service openApplication:bundleIDNSStr
options:options
clientPort:client_port
withResult:^(NSError *error) {
// The system service will cleanup the client port we
// created for us.
if (error)
attach_error_code =
(FBSOpenApplicationErrorCode)[error code];
[system_service release];
dispatch_semaphore_signal(semaphore);
}];
const uint32_t timeout_secs = 9;
dispatch_time_t timeout =
dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
if (!success) {
DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
attach_err.SetErrorString(
"debugserver timed out waiting for openApplication to complete.");
attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
} else if (attach_error_code != FBSOpenApplicationErrorCodeNone) {
SetFBSError(attach_error_code, attach_err);
DNBLogError("unable to launch the application with CFBundleIdentifier "
"'%s' bks_error = %ld",
bundleIDStr.c_str(), (NSInteger)attach_error_code);
}
dispatch_release(semaphore);
[pool drain];
}
#endif
#if defined(WITH_BKS)
if (launch_flavor == eLaunchFlavorBKS) {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
NSString *stdio_path = nil;
NSFileManager *file_manager = [NSFileManager defaultManager];
const char *null_path = "/dev/null";
stdio_path =
[file_manager stringWithFileSystemRepresentation:null_path
length:strlen(null_path)];
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
NSMutableDictionary *options = [NSMutableDictionary dictionary];
DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
"@\"%s\",options include stdio path: \"%s\", "
"BKSDebugOptionKeyDebugOnNextLaunch & "
"BKSDebugOptionKeyWaitForDebugger )",
bundleIDStr.c_str(), null_path);
[debug_options setObject:stdio_path
forKey:BKSDebugOptionKeyStandardOutPath];
[debug_options setObject:stdio_path
forKey:BKSDebugOptionKeyStandardErrorPath];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:BKSDebugOptionKeyWaitForDebugger];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:BKSDebugOptionKeyDebugOnNextLaunch];
[options setObject:debug_options
forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
BKSSystemService *system_service = [[BKSSystemService alloc] init];
mach_port_t client_port = [system_service createClientPort];
__block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block BKSOpenApplicationErrorCode attach_error_code =
BKSOpenApplicationErrorCodeNone;
NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
[system_service openApplication:bundleIDNSStr
options:options
clientPort:client_port
withResult:^(NSError *error) {
// The system service will cleanup the client port we
// created for us.
if (error)
attach_error_code =
(BKSOpenApplicationErrorCode)[error code];
[system_service release];
dispatch_semaphore_signal(semaphore);
}];
const uint32_t timeout_secs = 9;
dispatch_time_t timeout =
dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
if (!success) {
DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
attach_err.SetErrorString(
"debugserver timed out waiting for openApplication to complete.");
attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
} else if (attach_error_code != BKSOpenApplicationErrorCodeNone) {
SetBKSError(attach_error_code, attach_err);
DNBLogError("unable to launch the application with CFBundleIdentifier "
"'%s' bks_error = %ld",
bundleIDStr.c_str(), attach_error_code);
}
dispatch_release(semaphore);
[pool drain];
}
#endif
#if defined(WITH_SPRINGBOARD)
if (launch_flavor == eLaunchFlavorSpringBoard) {
SBSApplicationLaunchError sbs_error = 0;
const char *stdout_err = "/dev/null";
CFString stdio_path;
stdio_path.SetFileSystemRepresentation(stdout_err);
DNBLogThreadedIf(LOG_PROCESS, "SBSLaunchApplicationForDebugging ( @\"%s\" "
", NULL, NULL, NULL, @\"%s\", @\"%s\", "
"SBSApplicationDebugOnNextLaunch | "
"SBSApplicationLaunchWaitForDebugger )",
bundleIDStr.c_str(), stdout_err, stdout_err);
sbs_error = SBSLaunchApplicationForDebugging(
bundleIDCFStr,
(CFURLRef)NULL, // openURL
NULL, // launch_argv.get(),
NULL, // launch_envp.get(), // CFDictionaryRef environment
stdio_path.get(), stdio_path.get(),
SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger);
if (sbs_error != SBSApplicationLaunchErrorSuccess) {
attach_err.SetError(sbs_error, DNBError::SpringBoard);
return NULL;
}
}
#endif // WITH_SPRINGBOARD
DNBLogThreadedIf(LOG_PROCESS, "Successfully set DebugOnNextLaunch.");
return bundleIDCFStr;
#else // !(defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
// (WITH_FBS))
return NULL;
#endif
}
// Pass in the token you got from PrepareForAttach. If there is a process
// for that token, then the pid will be returned, otherwise INVALID_NUB_PROCESS
// will be returned.
nub_process_t MachProcess::CheckForProcess(const void *attach_token,
nub_launch_flavor_t launch_flavor) {
if (attach_token == NULL)
return INVALID_NUB_PROCESS;
#if defined(WITH_FBS)
if (launch_flavor == eLaunchFlavorFBS) {
NSString *bundleIDNSStr = (NSString *)attach_token;
FBSSystemService *systemService = [[FBSSystemService alloc] init];
pid_t pid = [systemService pidForApplication:bundleIDNSStr];
[systemService release];
if (pid == 0)
return INVALID_NUB_PROCESS;
else
return pid;
}
#endif
#if defined(WITH_BKS)
if (launch_flavor == eLaunchFlavorBKS) {
NSString *bundleIDNSStr = (NSString *)attach_token;
BKSSystemService *systemService = [[BKSSystemService alloc] init];
pid_t pid = [systemService pidForApplication:bundleIDNSStr];
[systemService release];
if (pid == 0)
return INVALID_NUB_PROCESS;
else
return pid;
}
#endif
#if defined(WITH_SPRINGBOARD)
if (launch_flavor == eLaunchFlavorSpringBoard) {
CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
Boolean got_it;
nub_process_t attach_pid;
got_it = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &attach_pid);
if (got_it)
return attach_pid;
else
return INVALID_NUB_PROCESS;
}
#endif
return INVALID_NUB_PROCESS;
}
// Call this to clean up after you have either attached or given up on the
// attach.
// Pass true for success if you have attached, false if you have not.
// The token will also be freed at this point, so you can't use it after calling
// this method.
void MachProcess::CleanupAfterAttach(const void *attach_token,
nub_launch_flavor_t launch_flavor,
bool success, DNBError &err_str) {
if (attach_token == NULL)
return;
#if defined(WITH_FBS)
if (launch_flavor == eLaunchFlavorFBS) {
if (!success) {
FBSCleanupAfterAttach(attach_token, err_str);
}
CFRelease((CFStringRef)attach_token);
}
#endif
#if defined(WITH_BKS)
if (launch_flavor == eLaunchFlavorBKS) {
if (!success) {
BKSCleanupAfterAttach(attach_token, err_str);
}
CFRelease((CFStringRef)attach_token);
}
#endif
#if defined(WITH_SPRINGBOARD)
// Tell SpringBoard to cancel the debug on next launch of this application
// if we failed to attach
if (launch_flavor == eMachProcessFlagsUsingSpringBoard) {
if (!success) {
SBSApplicationLaunchError sbs_error = 0;
CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
sbs_error = SBSLaunchApplicationForDebugging(
bundleIDCFStr, (CFURLRef)NULL, NULL, NULL, NULL, NULL,
SBSApplicationCancelDebugOnNextLaunch);
if (sbs_error != SBSApplicationLaunchErrorSuccess) {
err_str.SetError(sbs_error, DNBError::SpringBoard);
return;
}
}
CFRelease((CFStringRef)attach_token);
}
#endif
}
pid_t MachProcess::LaunchForDebug(
const char *path, char const *argv[], char const *envp[],
const char *working_directory, // NULL => don't change, non-NULL => set
// working directory for inferior to this
const char *stdin_path, const char *stdout_path, const char *stderr_path,
bool no_stdio, nub_launch_flavor_t launch_flavor, int disable_aslr,
const char *event_data, DNBError &launch_err) {
// Clear out and clean up from any current state
Clear();
DNBLogThreadedIf(LOG_PROCESS,
"%s( path = '%s', argv = %p, envp = %p, "
"launch_flavor = %u, disable_aslr = %d )",
__FUNCTION__, path, reinterpret_cast<const void *>(argv),
reinterpret_cast<const void *>(envp), launch_flavor,
disable_aslr);
// Fork a child process for debugging
SetState(eStateLaunching);
switch (launch_flavor) {
case eLaunchFlavorForkExec:
m_pid = MachProcess::ForkChildForPTraceDebugging(path, argv, envp, this,
launch_err);
break;
#ifdef WITH_FBS
case eLaunchFlavorFBS: {
const char *app_ext = strstr(path, ".app");
if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) {
std::string app_bundle_path(path, app_ext + strlen(".app"));
m_flags |= eMachProcessFlagsUsingFBS;
if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
no_stdio, disable_aslr, event_data,
launch_err) != 0)
return m_pid; // A successful SBLaunchForDebug() returns and assigns a
// non-zero m_pid.
else
break; // We tried a FBS launch, but didn't succeed lets get out
}
} break;
#endif
#ifdef WITH_BKS
case eLaunchFlavorBKS: {
const char *app_ext = strstr(path, ".app");
if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) {
std::string app_bundle_path(path, app_ext + strlen(".app"));
m_flags |= eMachProcessFlagsUsingBKS;
if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
no_stdio, disable_aslr, event_data,
launch_err) != 0)
return m_pid; // A successful SBLaunchForDebug() returns and assigns a
// non-zero m_pid.
else
break; // We tried a BKS launch, but didn't succeed lets get out
}
} break;
#endif
#ifdef WITH_SPRINGBOARD
case eLaunchFlavorSpringBoard: {
// .../whatever.app/whatever ?
// Or .../com.apple.whatever.app/whatever -- be careful of ".app" in
// "com.apple.whatever" here
const char *app_ext = strstr(path, ".app/");
if (app_ext == NULL) {
// .../whatever.app ?
int len = strlen(path);
if (len > 5) {
if (strcmp(path + len - 4, ".app") == 0) {
app_ext = path + len - 4;
}
}
}
if (app_ext) {
std::string app_bundle_path(path, app_ext + strlen(".app"));
if (SBLaunchForDebug(app_bundle_path.c_str(), argv, envp, no_stdio,
disable_aslr, launch_err) != 0)
return m_pid; // A successful SBLaunchForDebug() returns and assigns a
// non-zero m_pid.
else
break; // We tried a springboard launch, but didn't succeed lets get out
}
} break;
#endif
case eLaunchFlavorPosixSpawn:
m_pid = MachProcess::PosixSpawnChildForPTraceDebugging(
path, DNBArchProtocol::GetArchitecture(), argv, envp, working_directory,
stdin_path, stdout_path, stderr_path, no_stdio, this, disable_aslr,
launch_err);
break;
default:
// Invalid launch
launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
return INVALID_NUB_PROCESS;
}
if (m_pid == INVALID_NUB_PROCESS) {
// If we don't have a valid process ID and no one has set the error,
// then return a generic error
if (launch_err.Success())
launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
} else {
m_path = path;
size_t i;
char const *arg;
for (i = 0; (arg = argv[i]) != NULL; i++)
m_args.push_back(arg);
m_task.StartExceptionThread(launch_err);
if (launch_err.Fail()) {
if (launch_err.AsString() == NULL)
launch_err.SetErrorString("unable to start the exception thread");
DNBLog("Could not get inferior's Mach exception port, sending ptrace "
"PT_KILL and exiting.");
::ptrace(PT_KILL, m_pid, 0, 0);
m_pid = INVALID_NUB_PROCESS;
return INVALID_NUB_PROCESS;
}
StartSTDIOThread();
if (launch_flavor == eLaunchFlavorPosixSpawn) {
SetState(eStateAttaching);
errno = 0;
int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
if (err == 0) {
m_flags |= eMachProcessFlagsAttached;
DNBLogThreadedIf(LOG_PROCESS, "successfully spawned pid %d", m_pid);
launch_err.Clear();
} else {
SetState(eStateExited);
DNBError ptrace_err(errno, DNBError::POSIX);
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to spawned pid "
"%d (err = %i, errno = %i (%s))",
m_pid, err, ptrace_err.Status(),
ptrace_err.AsString());
launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
}
} else {
launch_err.Clear();
}
}
return m_pid;
}
pid_t MachProcess::PosixSpawnChildForPTraceDebugging(
const char *path, cpu_type_t cpu_type, char const *argv[],
char const *envp[], const char *working_directory, const char *stdin_path,
const char *stdout_path, const char *stderr_path, bool no_stdio,
MachProcess *process, int disable_aslr, DNBError &err) {
posix_spawnattr_t attr;
short flags;
DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv=%p, envp=%p, "
"working_dir=%s, stdin=%s, stdout=%s "
"stderr=%s, no-stdio=%i)",
__FUNCTION__, path, reinterpret_cast<const void *>(argv),
reinterpret_cast<const void *>(envp), working_directory,
stdin_path, stdout_path, stderr_path, no_stdio);
err.SetError(::posix_spawnattr_init(&attr), DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawnattr_init ( &attr )");
if (err.Fail())
return INVALID_NUB_PROCESS;
flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETSIGDEF |
POSIX_SPAWN_SETSIGMASK;
if (disable_aslr)
flags |= _POSIX_SPAWN_DISABLE_ASLR;
sigset_t no_signals;
sigset_t all_signals;
sigemptyset(&no_signals);
sigfillset(&all_signals);
::posix_spawnattr_setsigmask(&attr, &no_signals);
::posix_spawnattr_setsigdefault(&attr, &all_signals);
err.SetError(::posix_spawnattr_setflags(&attr, flags), DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded(
"::posix_spawnattr_setflags ( &attr, POSIX_SPAWN_START_SUSPENDED%s )",
flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR"
: "");
if (err.Fail())
return INVALID_NUB_PROCESS;
// Don't do this on SnowLeopard, _sometimes_ the TASK_BASIC_INFO will fail
// and we will fail to continue with our process...
// On SnowLeopard we should set "DYLD_NO_PIE" in the inferior environment....
#if !defined(__arm__)
// We don't need to do this for ARM, and we really shouldn't now that we
// have multiple CPU subtypes and no posix_spawnattr call that allows us
// to set which CPU subtype to launch...
if (cpu_type != 0) {
size_t ocount = 0;
err.SetError(::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = "
"0x%8.8x, count => %llu )",
cpu_type, (uint64_t)ocount);
if (err.Fail() != 0 || ocount != 1)
return INVALID_NUB_PROCESS;
}
#endif
PseudoTerminal pty;
posix_spawn_file_actions_t file_actions;
err.SetError(::posix_spawn_file_actions_init(&file_actions), DNBError::POSIX);
int file_actions_valid = err.Success();
if (!file_actions_valid || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawn_file_actions_init ( &file_actions )");
int pty_error = -1;
pid_t pid = INVALID_NUB_PROCESS;
if (file_actions_valid) {
if (stdin_path == NULL && stdout_path == NULL && stderr_path == NULL &&
!no_stdio) {
pty_error = pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
if (pty_error == PseudoTerminal::success) {
stdin_path = stdout_path = stderr_path = pty.SlaveName();
}
}
// if no_stdio or std paths not supplied, then route to "/dev/null".
if (no_stdio || stdin_path == NULL || stdin_path[0] == '\0')
stdin_path = "/dev/null";
if (no_stdio || stdout_path == NULL || stdout_path[0] == '\0')
stdout_path = "/dev/null";
if (no_stdio || stderr_path == NULL || stderr_path[0] == '\0')
stderr_path = "/dev/null";
err.SetError(::posix_spawn_file_actions_addopen(&file_actions, STDIN_FILENO,
stdin_path,
O_RDONLY | O_NOCTTY, 0),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
"filedes=STDIN_FILENO, path='%s')",
stdin_path);
err.SetError(::posix_spawn_file_actions_addopen(
&file_actions, STDOUT_FILENO, stdout_path,
O_WRONLY | O_NOCTTY | O_CREAT, 0640),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
"filedes=STDOUT_FILENO, path='%s')",
stdout_path);
err.SetError(::posix_spawn_file_actions_addopen(
&file_actions, STDERR_FILENO, stderr_path,
O_WRONLY | O_NOCTTY | O_CREAT, 0640),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
"filedes=STDERR_FILENO, path='%s')",
stderr_path);
// TODO: Verify if we can set the working directory back immediately
// after the posix_spawnp call without creating a race condition???
if (working_directory)
::chdir(working_directory);
err.SetError(::posix_spawnp(&pid, path, &file_actions, &attr,
const_cast<char *const *>(argv),
const_cast<char *const *>(envp)),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
"%p, attr = %p, argv = %p, envp = %p )",
pid, path, &file_actions, &attr, argv, envp);
} else {
// TODO: Verify if we can set the working directory back immediately
// after the posix_spawnp call without creating a race condition???
if (working_directory)
::chdir(working_directory);
err.SetError(::posix_spawnp(&pid, path, NULL, &attr,
const_cast<char *const *>(argv),
const_cast<char *const *>(envp)),
DNBError::POSIX);
if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
"%p, attr = %p, argv = %p, envp = %p )",
pid, path, NULL, &attr, argv, envp);
}
// We have seen some cases where posix_spawnp was returning a valid
// looking pid even when an error was returned, so clear it out
if (err.Fail())
pid = INVALID_NUB_PROCESS;
if (pty_error == 0) {
if (process != NULL) {
int master_fd = pty.ReleaseMasterFD();
process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
}
}
::posix_spawnattr_destroy(&attr);
if (pid != INVALID_NUB_PROCESS) {
cpu_type_t pid_cpu_type = MachProcess::GetCPUTypeForLocalProcess(pid);
DNBLogThreadedIf(LOG_PROCESS,
"MachProcess::%s ( ) pid=%i, cpu_type=0x%8.8x",
__FUNCTION__, pid, pid_cpu_type);
if (pid_cpu_type)
DNBArchProtocol::SetArchitecture(pid_cpu_type);
}
if (file_actions_valid) {
DNBError err2;
err2.SetError(::posix_spawn_file_actions_destroy(&file_actions),
DNBError::POSIX);
if (err2.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
err2.LogThreaded("::posix_spawn_file_actions_destroy ( &file_actions )");
}
return pid;
}
uint32_t MachProcess::GetCPUTypeForLocalProcess(pid_t pid) {
int mib[CTL_MAXNAME] = {
0,
};
size_t len = CTL_MAXNAME;
if (::sysctlnametomib("sysctl.proc_cputype", mib, &len))
return 0;
mib[len] = pid;
len++;
cpu_type_t cpu;
size_t cpu_len = sizeof(cpu);
if (::sysctl(mib, static_cast<u_int>(len), &cpu, &cpu_len, 0, 0))
cpu = 0;
return cpu;
}
pid_t MachProcess::ForkChildForPTraceDebugging(const char *path,
char const *argv[],
char const *envp[],
MachProcess *process,
DNBError &launch_err) {
PseudoTerminal::Status pty_error = PseudoTerminal::success;
// Use a fork that ties the child process's stdin/out/err to a pseudo
// terminal so we can read it in our MachProcess::STDIOThread
// as unbuffered io.
PseudoTerminal pty;
pid_t pid = pty.Fork(pty_error);
if (pid < 0) {
//--------------------------------------------------------------
// Status during fork.
//--------------------------------------------------------------
return pid;
} else if (pid == 0) {
//--------------------------------------------------------------
// Child process
//--------------------------------------------------------------
::ptrace(PT_TRACE_ME, 0, 0, 0); // Debug this process
::ptrace(PT_SIGEXC, 0, 0, 0); // Get BSD signals as mach exceptions
// If our parent is setgid, lets make sure we don't inherit those
// extra powers due to nepotism.
if (::setgid(getgid()) == 0) {
// Let the child have its own process group. We need to execute
// this call in both the child and parent to avoid a race condition
// between the two processes.
::setpgid(0, 0); // Set the child process group to match its pid
// Sleep a bit to before the exec call
::sleep(1);
// Turn this process into
::execv(path, const_cast<char *const *>(argv));
}
// Exit with error code. Child process should have taken
// over in above exec call and if the exec fails it will
// exit the child process below.
::exit(127);
} else {
//--------------------------------------------------------------
// Parent process
//--------------------------------------------------------------
// Let the child have its own process group. We need to execute
// this call in both the child and parent to avoid a race condition
// between the two processes.
::setpgid(pid, pid); // Set the child process group to match its pid
if (process != NULL) {
// Release our master pty file descriptor so the pty class doesn't
// close it and so we can continue to use it in our STDIO thread
int master_fd = pty.ReleaseMasterFD();
process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
}
}
return pid;
}
#if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
// This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
// or NULL if there was some problem getting the bundle id.
static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
DNBError &err_str) {
CFBundle bundle(app_bundle_path);
CFStringRef bundleIDCFStr = bundle.GetIdentifier();
std::string bundleID;
if (CFString::UTF8(bundleIDCFStr, bundleID) == NULL) {
struct stat app_bundle_stat;
char err_msg[PATH_MAX];
if (::stat(app_bundle_path, &app_bundle_stat) < 0) {
err_str.SetError(errno, DNBError::POSIX);
snprintf(err_msg, sizeof(err_msg), "%s: \"%s\"", err_str.AsString(),
app_bundle_path);
err_str.SetErrorString(err_msg);
DNBLogThreadedIf(LOG_PROCESS, "%s() error: %s", __FUNCTION__, err_msg);
} else {
err_str.SetError(-1, DNBError::Generic);
snprintf(err_msg, sizeof(err_msg),
"failed to extract CFBundleIdentifier from %s", app_bundle_path);
err_str.SetErrorString(err_msg);
DNBLogThreadedIf(
LOG_PROCESS,
"%s() error: failed to extract CFBundleIdentifier from '%s'",
__FUNCTION__, app_bundle_path);
}
return NULL;
}
DNBLogThreadedIf(LOG_PROCESS, "%s() extracted CFBundleIdentifier: %s",
__FUNCTION__, bundleID.c_str());
CFRetain(bundleIDCFStr);
return bundleIDCFStr;
}
#endif // #if defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
// (WITH_FBS)
#ifdef WITH_SPRINGBOARD
pid_t MachProcess::SBLaunchForDebug(const char *path, char const *argv[],
char const *envp[], bool no_stdio,
bool disable_aslr, DNBError &launch_err) {
// Clear out and clean up from any current state
Clear();
DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
// Fork a child process for debugging
SetState(eStateLaunching);
m_pid = MachProcess::SBForkChildForPTraceDebugging(path, argv, envp, no_stdio,
this, launch_err);
if (m_pid != 0) {
m_flags |= eMachProcessFlagsUsingSBS;
m_path = path;
size_t i;
char const *arg;
for (i = 0; (arg = argv[i]) != NULL; i++)
m_args.push_back(arg);
m_task.StartExceptionThread(launch_err);
if (launch_err.Fail()) {
if (launch_err.AsString() == NULL)
launch_err.SetErrorString("unable to start the exception thread");
DNBLog("Could not get inferior's Mach exception port, sending ptrace "
"PT_KILL and exiting.");
::ptrace(PT_KILL, m_pid, 0, 0);
m_pid = INVALID_NUB_PROCESS;
return INVALID_NUB_PROCESS;
}
StartSTDIOThread();
SetState(eStateAttaching);
int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
if (err == 0) {
m_flags |= eMachProcessFlagsAttached;
DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
} else {
SetState(eStateExited);
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
}
}
return m_pid;
}
#include <servers/bootstrap.h>
pid_t MachProcess::SBForkChildForPTraceDebugging(
const char *app_bundle_path, char const *argv[], char const *envp[],
bool no_stdio, MachProcess *process, DNBError &launch_err) {
DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
app_bundle_path, process);
CFAllocatorRef alloc = kCFAllocatorDefault;
if (argv[0] == NULL)
return INVALID_NUB_PROCESS;
size_t argc = 0;
// Count the number of arguments
while (argv[argc] != NULL)
argc++;
// Enumerate the arguments
size_t first_launch_arg_idx = 1;
CFReleaser<CFMutableArrayRef> launch_argv;
if (argv[first_launch_arg_idx]) {
size_t launch_argc = argc > 0 ? argc - 1 : 0;
launch_argv.reset(
::CFArrayCreateMutable(alloc, launch_argc, &kCFTypeArrayCallBacks));
size_t i;
char const *arg;
CFString launch_arg;
for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
i++) {
launch_arg.reset(
::CFStringCreateWithCString(alloc, arg, kCFStringEncodingUTF8));
if (launch_arg.get() != NULL)
CFArrayAppendValue(launch_argv.get(), launch_arg.get());
else
break;
}
}
// Next fill in the arguments dictionary. Note, the envp array is of the form
// Variable=value but SpringBoard wants a CF dictionary. So we have to
// convert
// this here.
CFReleaser<CFMutableDictionaryRef> launch_envp;
if (envp[0]) {
launch_envp.reset(
::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks));
const char *value;
int name_len;
CFString name_string, value_string;
for (int i = 0; envp[i] != NULL; i++) {
value = strstr(envp[i], "=");
// If the name field is empty or there's no =, skip it. Somebody's
// messing with us.
if (value == NULL || value == envp[i])
continue;
name_len = value - envp[i];
// Now move value over the "="
value++;
name_string.reset(
::CFStringCreateWithBytes(alloc, (const UInt8 *)envp[i], name_len,
kCFStringEncodingUTF8, false));
value_string.reset(
::CFStringCreateWithCString(alloc, value, kCFStringEncodingUTF8));
CFDictionarySetValue(launch_envp.get(), name_string.get(),
value_string.get());
}
}
CFString stdio_path;
PseudoTerminal pty;
if (!no_stdio) {
PseudoTerminal::Status pty_err =
pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
if (pty_err == PseudoTerminal::success) {
const char *slave_name = pty.SlaveName();
DNBLogThreadedIf(LOG_PROCESS,
"%s() successfully opened master pty, slave is %s",
__FUNCTION__, slave_name);
if (slave_name && slave_name[0]) {
::chmod(slave_name, S_IRWXU | S_IRWXG | S_IRWXO);
stdio_path.SetFileSystemRepresentation(slave_name);
}
}
}
if (stdio_path.get() == NULL) {
stdio_path.SetFileSystemRepresentation("/dev/null");
}
CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
if (bundleIDCFStr == NULL)
return INVALID_NUB_PROCESS;
// This is just for logging:
std::string bundleID;
CFString::UTF8(bundleIDCFStr, bundleID);
DNBLogThreadedIf(LOG_PROCESS, "%s() serialized launch arg array",
__FUNCTION__);
// Find SpringBoard
SBSApplicationLaunchError sbs_error = 0;
sbs_error = SBSLaunchApplicationForDebugging(
bundleIDCFStr,
(CFURLRef)NULL, // openURL
launch_argv.get(),
launch_envp.get(), // CFDictionaryRef environment
stdio_path.get(), stdio_path.get(),
SBSApplicationLaunchWaitForDebugger | SBSApplicationLaunchUnlockDevice);
launch_err.SetError(sbs_error, DNBError::SpringBoard);
if (sbs_error == SBSApplicationLaunchErrorSuccess) {
static const useconds_t pid_poll_interval = 200000;
static const useconds_t pid_poll_timeout = 30000000;
useconds_t pid_poll_total = 0;
nub_process_t pid = INVALID_NUB_PROCESS;
Boolean pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
// Poll until the process is running, as long as we are getting valid
// responses and the timeout hasn't expired
// A return PID of 0 means the process is not running, which may be because
// it hasn't been (asynchronously) started
// yet, or that it died very quickly (if you weren't using waitForDebugger).
while (!pid_found && pid_poll_total < pid_poll_timeout) {
usleep(pid_poll_interval);
pid_poll_total += pid_poll_interval;
DNBLogThreadedIf(LOG_PROCESS,
"%s() polling Springboard for pid for %s...",
__FUNCTION__, bundleID.c_str());
pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
}
CFRelease(bundleIDCFStr);
if (pid_found) {
if (process != NULL) {
// Release our master pty file descriptor so the pty class doesn't
// close it and so we can continue to use it in our STDIO thread
int master_fd = pty.ReleaseMasterFD();
process->SetChildFileDescriptors(master_fd, master_fd, master_fd);
}
DNBLogThreadedIf(LOG_PROCESS, "%s() => pid = %4.4x", __FUNCTION__, pid);
} else {
DNBLogError("failed to lookup the process ID for CFBundleIdentifier %s.",
bundleID.c_str());
}
return pid;
}
DNBLogError("unable to launch the application with CFBundleIdentifier '%s' "
"sbs_error = %u",
bundleID.c_str(), sbs_error);
return INVALID_NUB_PROCESS;
}
#endif // #ifdef WITH_SPRINGBOARD
#if defined(WITH_BKS) || defined(WITH_FBS)
pid_t MachProcess::BoardServiceLaunchForDebug(
const char *path, char const *argv[], char const *envp[], bool no_stdio,
bool disable_aslr, const char *event_data, DNBError &launch_err) {
DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
// Fork a child process for debugging
SetState(eStateLaunching);
m_pid = BoardServiceForkChildForPTraceDebugging(
path, argv, envp, no_stdio, disable_aslr, event_data, launch_err);
if (m_pid != 0) {
m_path = path;
size_t i;
char const *arg;
for (i = 0; (arg = argv[i]) != NULL; i++)
m_args.push_back(arg);
m_task.StartExceptionThread(launch_err);
if (launch_err.Fail()) {
if (launch_err.AsString() == NULL)
launch_err.SetErrorString("unable to start the exception thread");
DNBLog("Could not get inferior's Mach exception port, sending ptrace "
"PT_KILL and exiting.");
::ptrace(PT_KILL, m_pid, 0, 0);
m_pid = INVALID_NUB_PROCESS;
return INVALID_NUB_PROCESS;
}
StartSTDIOThread();
SetState(eStateAttaching);
int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
if (err == 0) {
m_flags |= eMachProcessFlagsAttached;
DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
} else {
SetState(eStateExited);
DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
}
}
return m_pid;
}
pid_t MachProcess::BoardServiceForkChildForPTraceDebugging(
const char *app_bundle_path, char const *argv[], char const *envp[],
bool no_stdio, bool disable_aslr, const char *event_data,
DNBError &launch_err) {
if (argv[0] == NULL)
return INVALID_NUB_PROCESS;
DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
app_bundle_path, this);
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
size_t argc = 0;
// Count the number of arguments
while (argv[argc] != NULL)
argc++;
// Enumerate the arguments
size_t first_launch_arg_idx = 1;
NSMutableArray *launch_argv = nil;
if (argv[first_launch_arg_idx]) {
size_t launch_argc = argc > 0 ? argc - 1 : 0;
launch_argv = [NSMutableArray arrayWithCapacity:launch_argc];
size_t i;
char const *arg;
NSString *launch_arg;
for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
i++) {
launch_arg = [NSString stringWithUTF8String:arg];
// FIXME: Should we silently eat an argument that we can't convert into a
// UTF8 string?
if (launch_arg != nil)
[launch_argv addObject:launch_arg];
else
break;
}
}
NSMutableDictionary *launch_envp = nil;
if (envp[0]) {
launch_envp = [[NSMutableDictionary alloc] init];
const char *value;
int name_len;
NSString *name_string, *value_string;
for (int i = 0; envp[i] != NULL; i++) {
value = strstr(envp[i], "=");
// If the name field is empty or there's no =, skip it. Somebody's
// messing with us.
if (value == NULL || value == envp[i])
continue;
name_len = value - envp[i];
// Now move value over the "="
value++;
name_string = [[NSString alloc] initWithBytes:envp[i]
length:name_len
encoding:NSUTF8StringEncoding];
value_string = [NSString stringWithUTF8String:value];
[launch_envp setObject:value_string forKey:name_string];
}
}
NSString *stdio_path = nil;
NSFileManager *file_manager = [NSFileManager defaultManager];
PseudoTerminal pty;
if (!no_stdio) {
PseudoTerminal::Status pty_err =
pty.OpenFirstAvailableMaster(O_RDWR | O_NOCTTY);
if (pty_err == PseudoTerminal::success) {
const char *slave_name = pty.SlaveName();
DNBLogThreadedIf(LOG_PROCESS,
"%s() successfully opened master pty, slave is %s",
__FUNCTION__, slave_name);
if (slave_name && slave_name[0]) {
::chmod(slave_name, S_IRWXU | S_IRWXG | S_IRWXO);
stdio_path = [file_manager
stringWithFileSystemRepresentation:slave_name
length:strlen(slave_name)];
}
}
}
if (stdio_path == nil) {
const char *null_path = "/dev/null";
stdio_path =
[file_manager stringWithFileSystemRepresentation:null_path
length:strlen(null_path)];
}
CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
if (bundleIDCFStr == NULL) {
[pool drain];
return INVALID_NUB_PROCESS;
}
// Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
// toll-free bridging here:
NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
// Okay, now let's assemble all these goodies into the BackBoardServices
// options mega-dictionary:
NSMutableDictionary *options = nullptr;
pid_t return_pid = INVALID_NUB_PROCESS;
bool success = false;
#ifdef WITH_BKS
if (m_flags & eMachProcessFlagsUsingBKS) {
options =
BKSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
stdio_path, disable_aslr, event_data);
success = BKSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
&return_pid);
}
#endif
#ifdef WITH_FBS
if (m_flags & eMachProcessFlagsUsingFBS) {
options =
FBSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
stdio_path, disable_aslr, event_data);
success = FBSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
&return_pid);
}
#endif
if (success) {
int master_fd = pty.ReleaseMasterFD();
SetChildFileDescriptors(master_fd, master_fd, master_fd);
CFString::UTF8(bundleIDCFStr, m_bundle_id);
}
[pool drain];
return return_pid;
}
bool MachProcess::BoardServiceSendEvent(const char *event_data,
DNBError &send_err) {
bool return_value = true;
if (event_data == NULL || *event_data == '\0') {
DNBLogError("SendEvent called with NULL event data.");
send_err.SetErrorString("SendEvent called with empty event data");
return false;
}
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
if (strcmp(event_data, "BackgroundApplication") == 0) {
// This is an event I cooked up. What you actually do is foreground the system
// app, so:
#ifdef WITH_BKS
if (m_flags & eMachProcessFlagsUsingBKS) {
return_value = BKSCallOpenApplicationFunction(nil, nil, send_err, NULL);
}
#endif
#ifdef WITH_FBS
if (m_flags & eMachProcessFlagsUsingFBS) {
return_value = FBSCallOpenApplicationFunction(nil, nil, send_err, NULL);
}
#endif
if (!return_value) {
DNBLogError("Failed to background application, error: %s.",
send_err.AsString());
}
} else {
if (m_bundle_id.empty()) {
// See if we can figure out the bundle ID for this PID:
DNBLogError(
"Tried to send event \"%s\" to a process that has no bundle ID.",
event_data);
return false;
}
NSString *bundleIDNSStr =
[NSString stringWithUTF8String:m_bundle_id.c_str()];
NSMutableDictionary *options = [NSMutableDictionary dictionary];
#ifdef WITH_BKS
if (m_flags & eMachProcessFlagsUsingBKS) {
if (!BKSAddEventDataToOptions(options, event_data, send_err)) {
[pool drain];
return false;
}
return_value = BKSCallOpenApplicationFunction(bundleIDNSStr, options,
send_err, NULL);
DNBLogThreadedIf(LOG_PROCESS,
"Called BKSCallOpenApplicationFunction to send event.");
}
#endif
#ifdef WITH_FBS
if (m_flags & eMachProcessFlagsUsingFBS) {
if (!FBSAddEventDataToOptions(options, event_data, send_err)) {
[pool drain];
return false;
}
return_value = FBSCallOpenApplicationFunction(bundleIDNSStr, options,
send_err, NULL);
DNBLogThreadedIf(LOG_PROCESS,
"Called FBSCallOpenApplicationFunction to send event.");
}
#endif
if (!return_value) {
DNBLogError("Failed to send event: %s, error: %s.", event_data,
send_err.AsString());
}
}
[pool drain];
return return_value;
}
#endif // defined(WITH_BKS) || defined (WITH_FBS)
#ifdef WITH_BKS
void MachProcess::BKSCleanupAfterAttach(const void *attach_token,
DNBError &err_str) {
bool success;
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
// toll-free bridging here:
NSString *bundleIDNSStr = (NSString *)attach_token;
// Okay, now let's assemble all these goodies into the BackBoardServices
// options mega-dictionary:
// First we have the debug sub-dictionary:
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:BKSDebugOptionKeyCancelDebugOnNextLaunch];
// That will go in the overall dictionary:
NSMutableDictionary *options = [NSMutableDictionary dictionary];
[options setObject:debug_options
forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
success =
BKSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
if (!success) {
DNBLogError("error trying to cancel debug on next launch for %s: %s",
[bundleIDNSStr UTF8String], err_str.AsString());
}
[pool drain];
}
#endif // WITH_BKS
#ifdef WITH_FBS
void MachProcess::FBSCleanupAfterAttach(const void *attach_token,
DNBError &err_str) {
bool success;
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
// Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
// toll-free bridging here:
NSString *bundleIDNSStr = (NSString *)attach_token;
// Okay, now let's assemble all these goodies into the BackBoardServices
// options mega-dictionary:
// First we have the debug sub-dictionary:
NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
[debug_options setObject:[NSNumber numberWithBool:YES]
forKey:FBSDebugOptionKeyCancelDebugOnNextLaunch];
// That will go in the overall dictionary:
NSMutableDictionary *options = [NSMutableDictionary dictionary];
[options setObject:debug_options
forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
success =
FBSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
if (!success) {
DNBLogError("error trying to cancel debug on next launch for %s: %s",
[bundleIDNSStr UTF8String], err_str.AsString());
}
[pool drain];
}
#endif // WITH_FBS
Reference in New Issue View Git Blame Copy Permalink