lldb/tools/debugserver/source/MacOSX/MachProcess.mm

   1 //===-- MachProcess.cpp -----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  Created by Greg Clayton on 6/15/07.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "DNB.h"
  14 #include "MacOSX/CFUtils.h"
  15 #include "SysSignal.h"
  16 #include <dlfcn.h>
  17 #include <inttypes.h>
  18 #include <mach-o/loader.h>
  19 #include <mach/mach.h>
  20 #include <mach/task.h>
  21 #include <pthread.h>
  22 #include <signal.h>
  23 #include <spawn.h>
  24 #include <sys/fcntl.h>
  25 #include <sys/ptrace.h>
  26 #include <sys/stat.h>
  27 #include <sys/sysctl.h>
  28 #include <sys/time.h>
  29 #include <sys/types.h>
  30 #include <unistd.h>
  31 #include <uuid/uuid.h>
  32
  33 #include <algorithm>
  34 #include <chrono>
  35 #include <map>
  36
  37 #include <TargetConditionals.h>
  38 #import <Foundation/Foundation.h>
  39
  40 #include "DNBDataRef.h"
  41 #include "DNBLog.h"
  42 #include "DNBThreadResumeActions.h"
  43 #include "DNBTimer.h"
  44 #include "MachProcess.h"
  45 #include "PseudoTerminal.h"
  46
  47 #include "CFBundle.h"
  48 #include "CFString.h"
  49
  50 #ifndef PLATFORM_BRIDGEOS
  51 #define PLATFORM_BRIDGEOS 5
  52 #endif
  53
  54 #ifndef PLATFORM_MACCATALYST
  55 #define PLATFORM_MACCATALYST 6
  56 #endif
  57
  58 #ifndef PLATFORM_IOSSIMULATOR
  59 #define PLATFORM_IOSSIMULATOR 7
  60 #endif
  61
  62 #ifndef PLATFORM_TVOSSIMULATOR
  63 #define PLATFORM_TVOSSIMULATOR 8
  64 #endif
  65
  66 #ifndef PLATFORM_WATCHOSSIMULATOR
  67 #define PLATFORM_WATCHOSSIMULATOR 9
  68 #endif
  69
  70 #ifndef PLATFORM_DRIVERKIT
  71 #define PLATFORM_DRIVERKIT 10
  72 #endif
  73
  74 #ifdef WITH_SPRINGBOARD
  75
  76 #include <CoreFoundation/CoreFoundation.h>
  77 #include <SpringBoardServices/SBSWatchdogAssertion.h>
  78 #include <SpringBoardServices/SpringBoardServer.h>
  79
  80 #endif // WITH_SPRINGBOARD
  81
  82 #if WITH_CAROUSEL
  83 // For definition of CSLSOpenApplicationOptionForClockKit.
  84 #include <CarouselServices/CSLSOpenApplicationOptions.h>
  85 #endif // WITH_CAROUSEL
  86
  87 #if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
  88 // This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
  89 // or NULL if there was some problem getting the bundle id.
  90 static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
  91                                        DNBError &err_str);
  92 #endif
  93
  94 #if defined(WITH_BKS) || defined(WITH_FBS)
  95 #import <Foundation/Foundation.h>
  96 static const int OPEN_APPLICATION_TIMEOUT_ERROR = 111;
  97 typedef void (*SetErrorFunction)(NSInteger, std::string, DNBError &);
  98 typedef bool (*CallOpenApplicationFunction)(NSString *bundleIDNSStr,
  99                                             NSDictionary *options,
 100                                             DNBError &error, pid_t *return_pid);
 101
 102 // This function runs the BKSSystemService (or FBSSystemService) method
 103 // openApplication:options:clientPort:withResult,
 104 // messaging the app passed in bundleIDNSStr.
 105 // The function should be run inside of an NSAutoReleasePool.
 106 //
 107 // It will use the "options" dictionary passed in, and fill the error passed in
 108 // if there is an error.
 109 // If return_pid is not NULL, we'll fetch the pid that was made for the
 110 // bundleID.
 111 // If bundleIDNSStr is NULL, then the system application will be messaged.
 112
 113 template <typename OpenFlavor, typename ErrorFlavor,
 114           ErrorFlavor no_error_enum_value, SetErrorFunction error_function>
 115 static bool CallBoardSystemServiceOpenApplication(NSString *bundleIDNSStr,
 116                                                   NSDictionary *options,
 117                                                   DNBError &error,
 118                                                   pid_t *return_pid) {
 119   // Now make our systemService:
 120   OpenFlavor *system_service = [[OpenFlavor alloc] init];
 121
 122   if (bundleIDNSStr == nil) {
 123     bundleIDNSStr = [system_service systemApplicationBundleIdentifier];
 124     if (bundleIDNSStr == nil) {
 125       // Okay, no system app...
 126       error.SetErrorString("No system application to message.");
 127       return false;
 128     }
 129   }
 130
 131   mach_port_t client_port = [system_service createClientPort];
 132   __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
 133   __block ErrorFlavor open_app_error = no_error_enum_value;
 134   __block std::string open_app_error_string;
 135   bool wants_pid = (return_pid != NULL);
 136   __block pid_t pid_in_block;
 137
 138   const char *cstr = [bundleIDNSStr UTF8String];
 139   if (!cstr)
 140     cstr = "<Unknown Bundle ID>";
 141
 142   NSString *description = [options description];
 143   DNBLog("[LaunchAttach] START (%d) templated *Board launcher: app lunch "
 144          "request for "
 145          "'%s' - options:\n%s",
 146          getpid(), cstr, [description UTF8String]);
 147   [system_service
 148       openApplication:bundleIDNSStr
 149               options:options
 150            clientPort:client_port
 151            withResult:^(NSError *bks_error) {
 152              // The system service will cleanup the client port we created for
 153              // us.
 154              if (bks_error)
 155                open_app_error = (ErrorFlavor)[bks_error code];
 156
 157              if (open_app_error == no_error_enum_value) {
 158                if (wants_pid) {
 159                  pid_in_block =
 160                      [system_service pidForApplication:bundleIDNSStr];
 161                  DNBLog("[LaunchAttach] In completion handler, got pid for "
 162                         "bundle id "
 163                         "'%s', pid: %d.",
 164                         cstr, pid_in_block);
 165                } else {
 166                  DNBLog("[LaunchAttach] In completion handler, launch was "
 167                         "successful, "
 168                         "debugserver did not ask for the pid");
 169                }
 170              } else {
 171                const char *error_str =
 172                    [(NSString *)[bks_error localizedDescription] UTF8String];
 173                if (error_str) {
 174                  open_app_error_string = error_str;
 175                  DNBLogError(
 176                      "[LaunchAttach] END (%d) In app launch attempt, got error "
 177                      "localizedDescription '%s'.",
 178                      getpid(), error_str);
 179                  const char *obj_desc =
 180                       [NSString stringWithFormat:@"%@", bks_error].UTF8String;
 181                  DNBLogError(
 182                      "[LaunchAttach] END (%d) In app launch attempt, got error "
 183                      "NSError object description: '%s'.",
 184                      getpid(), obj_desc);
 185                }
 186                DNBLogThreadedIf(LOG_PROCESS,
 187                                 "In completion handler for send "
 188                                 "event, got error \"%s\"(%ld).",
 189                                 error_str ? error_str : "<unknown error>",
 190                                 (long)open_app_error);
 191              }
 192
 193              [system_service release];
 194              dispatch_semaphore_signal(semaphore);
 195            }
 196
 197   ];
 198
 199   const uint32_t timeout_secs = 30;
 200
 201   dispatch_time_t timeout =
 202       dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
 203
 204   long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
 205
 206   dispatch_release(semaphore);
 207
 208   DNBLog("[LaunchAttach] END (%d) templated *Board launcher finished app lunch "
 209          "request for "
 210          "'%s'",
 211          getpid(), cstr);
 212
 213   if (!success) {
 214     DNBLogError("[LaunchAttach] END (%d) timed out trying to send "
 215                 "openApplication to %s.",
 216                 getpid(), cstr);
 217     error.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
 218     error.SetErrorString("timed out trying to launch app");
 219   } else if (open_app_error != no_error_enum_value) {
 220     error_function(open_app_error, open_app_error_string, error);
 221     DNBLogError("[LaunchAttach] END (%d) unable to launch the application with "
 222                 "CFBundleIdentifier '%s' "
 223                 "bks_error = %ld",
 224                 getpid(), cstr, (long)open_app_error);
 225     success = false;
 226   } else if (wants_pid) {
 227     *return_pid = pid_in_block;
 228     DNBLogThreadedIf(
 229         LOG_PROCESS,
 230         "Out of completion handler, pid from block %d and passing out: %d",
 231         pid_in_block, *return_pid);
 232   }
 233
 234   return success;
 235 }
 236 #endif
 237
 238 #if defined(WITH_BKS) || defined(WITH_FBS)
 239 static void SplitEventData(const char *data, std::vector<std::string> &elements)
 240 {
 241   elements.clear();
 242   if (!data)
 243     return;
 244
 245   const char *start = data;
 246
 247   while (*start != '\0') {
 248     const char *token = strchr(start, ':');
 249     if (!token) {
 250       elements.push_back(std::string(start));
 251       return;
 252     }
 253     if (token != start)
 254       elements.push_back(std::string(start, token - start));
 255     start = ++token;
 256   }
 257 }
 258 #endif
 259
 260 #ifdef WITH_BKS
 261 #import <Foundation/Foundation.h>
 262 extern "C" {
 263 #import <BackBoardServices/BKSOpenApplicationConstants_Private.h>
 264 #import <BackBoardServices/BKSSystemService_LaunchServices.h>
 265 #import <BackBoardServices/BackBoardServices.h>
 266 }
 267
 268 static bool IsBKSProcess(nub_process_t pid) {
 269   BKSApplicationStateMonitor *state_monitor =
 270       [[BKSApplicationStateMonitor alloc] init];
 271   BKSApplicationState app_state =
 272       [state_monitor mostElevatedApplicationStateForPID:pid];
 273   return app_state != BKSApplicationStateUnknown;
 274 }
 275
 276 static void SetBKSError(NSInteger error_code,
 277                         std::string error_description,
 278                         DNBError &error) {
 279   error.SetError(error_code, DNBError::BackBoard);
 280   NSString *err_nsstr = ::BKSOpenApplicationErrorCodeToString(
 281       (BKSOpenApplicationErrorCode)error_code);
 282   std::string err_str = "unknown BKS error";
 283   if (error_description.empty() == false) {
 284     err_str = error_description;
 285   } else if (err_nsstr != nullptr) {
 286     err_str = [err_nsstr UTF8String];
 287   }
 288   error.SetErrorString(err_str.c_str());
 289 }
 290
 291 static bool BKSAddEventDataToOptions(NSMutableDictionary *options,
 292                                      const char *event_data,
 293                                      DNBError &option_error) {
 294   std::vector<std::string> values;
 295   SplitEventData(event_data, values);
 296   bool found_one = false;
 297   for (std::string value : values)
 298   {
 299       if (value.compare("BackgroundContentFetching") == 0) {
 300         DNBLog("Setting ActivateForEvent key in options dictionary.");
 301         NSDictionary *event_details = [NSDictionary dictionary];
 302         NSDictionary *event_dictionary = [NSDictionary
 303             dictionaryWithObject:event_details
 304                           forKey:
 305                               BKSActivateForEventOptionTypeBackgroundContentFetching];
 306         [options setObject:event_dictionary
 307                     forKey:BKSOpenApplicationOptionKeyActivateForEvent];
 308         found_one = true;
 309       } else if (value.compare("ActivateSuspended") == 0) {
 310         DNBLog("Setting ActivateSuspended key in options dictionary.");
 311         [options setObject:@YES forKey: BKSOpenApplicationOptionKeyActivateSuspended];
 312         found_one = true;
 313       } else {
 314         DNBLogError("Unrecognized event type: %s.  Ignoring.", value.c_str());
 315         option_error.SetErrorString("Unrecognized event data");
 316       }
 317   }
 318   return found_one;
 319 }
 320
 321 static NSMutableDictionary *BKSCreateOptionsDictionary(
 322     const char *app_bundle_path, NSMutableArray *launch_argv,
 323     NSMutableDictionary *launch_envp, NSString *stdio_path, bool disable_aslr,
 324     const char *event_data) {
 325   NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
 326   if (launch_argv != nil)
 327     [debug_options setObject:launch_argv forKey:BKSDebugOptionKeyArguments];
 328   if (launch_envp != nil)
 329     [debug_options setObject:launch_envp forKey:BKSDebugOptionKeyEnvironment];
 330
 331   [debug_options setObject:stdio_path forKey:BKSDebugOptionKeyStandardOutPath];
 332   [debug_options setObject:stdio_path
 333                     forKey:BKSDebugOptionKeyStandardErrorPath];
 334   [debug_options setObject:[NSNumber numberWithBool:YES]
 335                     forKey:BKSDebugOptionKeyWaitForDebugger];
 336   if (disable_aslr)
 337     [debug_options setObject:[NSNumber numberWithBool:YES]
 338                       forKey:BKSDebugOptionKeyDisableASLR];
 339
 340   // That will go in the overall dictionary:
 341
 342   NSMutableDictionary *options = [NSMutableDictionary dictionary];
 343   [options setObject:debug_options
 344               forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
 345   // And there are some other options at the top level in this dictionary:
 346   [options setObject:[NSNumber numberWithBool:YES]
 347               forKey:BKSOpenApplicationOptionKeyUnlockDevice];
 348
 349   DNBError error;
 350   BKSAddEventDataToOptions(options, event_data, error);
 351
 352   return options;
 353 }
 354
 355 static CallOpenApplicationFunction BKSCallOpenApplicationFunction =
 356     CallBoardSystemServiceOpenApplication<
 357         BKSSystemService, BKSOpenApplicationErrorCode,
 358         BKSOpenApplicationErrorCodeNone, SetBKSError>;
 359 #endif // WITH_BKS
 360
 361 #ifdef WITH_FBS
 362 #import <Foundation/Foundation.h>
 363 extern "C" {
 364 #import <FrontBoardServices/FBSOpenApplicationConstants_Private.h>
 365 #import <FrontBoardServices/FBSSystemService_LaunchServices.h>
 366 #import <FrontBoardServices/FrontBoardServices.h>
 367 #import <MobileCoreServices/LSResourceProxy.h>
 368 #import <MobileCoreServices/MobileCoreServices.h>
 369 }
 370
 371 #ifdef WITH_BKS
 372 static bool IsFBSProcess(nub_process_t pid) {
 373   BKSApplicationStateMonitor *state_monitor =
 374       [[BKSApplicationStateMonitor alloc] init];
 375   BKSApplicationState app_state =
 376       [state_monitor mostElevatedApplicationStateForPID:pid];
 377   return app_state != BKSApplicationStateUnknown;
 378 }
 379 #else
 380 static bool IsFBSProcess(nub_process_t pid) {
 381   // FIXME: What is the FBS equivalent of BKSApplicationStateMonitor
 382   return false;
 383 }
 384 #endif
 385
 386 static void SetFBSError(NSInteger error_code,
 387                         std::string error_description,
 388                         DNBError &error) {
 389   error.SetError((DNBError::ValueType)error_code, DNBError::FrontBoard);
 390   NSString *err_nsstr = ::FBSOpenApplicationErrorCodeToString(
 391       (FBSOpenApplicationErrorCode)error_code);
 392   std::string err_str = "unknown FBS error";
 393   if (error_description.empty() == false) {
 394     err_str = error_description;
 395   } else if (err_nsstr != nullptr) {
 396     err_str = [err_nsstr UTF8String];
 397   }
 398   error.SetErrorString(err_str.c_str());
 399 }
 400
 401 static bool FBSAddEventDataToOptions(NSMutableDictionary *options,
 402                                      const char *event_data,
 403                                      DNBError &option_error) {
 404   std::vector<std::string> values;
 405   SplitEventData(event_data, values);
 406   bool found_one = false;
 407   for (std::string value : values)
 408   {
 409       if (value.compare("BackgroundContentFetching") == 0) {
 410         DNBLog("Setting ActivateForEvent key in options dictionary.");
 411         NSDictionary *event_details = [NSDictionary dictionary];
 412         NSDictionary *event_dictionary = [NSDictionary
 413             dictionaryWithObject:event_details
 414                           forKey:
 415                               FBSActivateForEventOptionTypeBackgroundContentFetching];
 416         [options setObject:event_dictionary
 417                     forKey:FBSOpenApplicationOptionKeyActivateForEvent];
 418         found_one = true;
 419       } else if (value.compare("ActivateSuspended") == 0) {
 420         DNBLog("Setting ActivateSuspended key in options dictionary.");
 421         [options setObject:@YES forKey: FBSOpenApplicationOptionKeyActivateSuspended];
 422         found_one = true;
 423 #if WITH_CAROUSEL
 424       } else if (value.compare("WatchComplicationLaunch") == 0) {
 425         DNBLog("Setting FBSOpenApplicationOptionKeyActivateSuspended key in options dictionary.");
 426         [options setObject:@YES forKey: CSLSOpenApplicationOptionForClockKit];
 427         found_one = true;
 428 #endif // WITH_CAROUSEL
 429       } else {
 430         DNBLogError("Unrecognized event type: %s.  Ignoring.", value.c_str());
 431         option_error.SetErrorString("Unrecognized event data.");
 432       }
 433   }
 434   return found_one;
 435 }
 436
 437 static NSMutableDictionary *
 438 FBSCreateOptionsDictionary(const char *app_bundle_path,
 439                            NSMutableArray *launch_argv,
 440                            NSDictionary *launch_envp, NSString *stdio_path,
 441                            bool disable_aslr, const char *event_data) {
 442   NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
 443
 444   if (launch_argv != nil)
 445     [debug_options setObject:launch_argv forKey:FBSDebugOptionKeyArguments];
 446   if (launch_envp != nil)
 447     [debug_options setObject:launch_envp forKey:FBSDebugOptionKeyEnvironment];
 448
 449   [debug_options setObject:stdio_path forKey:FBSDebugOptionKeyStandardOutPath];
 450   [debug_options setObject:stdio_path
 451                     forKey:FBSDebugOptionKeyStandardErrorPath];
 452   [debug_options setObject:[NSNumber numberWithBool:YES]
 453                     forKey:FBSDebugOptionKeyWaitForDebugger];
 454   if (disable_aslr)
 455     [debug_options setObject:[NSNumber numberWithBool:YES]
 456                       forKey:FBSDebugOptionKeyDisableASLR];
 457
 458   // That will go in the overall dictionary:
 459
 460   NSMutableDictionary *options = [NSMutableDictionary dictionary];
 461   [options setObject:debug_options
 462               forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
 463   // And there are some other options at the top level in this dictionary:
 464   [options setObject:[NSNumber numberWithBool:YES]
 465               forKey:FBSOpenApplicationOptionKeyUnlockDevice];
 466
 467   // We have to get the "sequence ID & UUID" for this app bundle path and send
 468   // them to FBS:
 469
 470   NSURL *app_bundle_url =
 471       [NSURL fileURLWithPath:[NSString stringWithUTF8String:app_bundle_path]
 472                  isDirectory:YES];
 473   LSApplicationProxy *app_proxy =
 474       [LSApplicationProxy applicationProxyForBundleURL:app_bundle_url];
 475   if (app_proxy) {
 476     DNBLog("Sending AppProxy info: sequence no: %lu, GUID: %s.",
 477            app_proxy.sequenceNumber,
 478            [app_proxy.cacheGUID.UUIDString UTF8String]);
 479     [options
 480         setObject:[NSNumber numberWithUnsignedInteger:app_proxy.sequenceNumber]
 481            forKey:FBSOpenApplicationOptionKeyLSSequenceNumber];
 482     [options setObject:app_proxy.cacheGUID.UUIDString
 483                 forKey:FBSOpenApplicationOptionKeyLSCacheGUID];
 484   }
 485
 486   DNBError error;
 487   FBSAddEventDataToOptions(options, event_data, error);
 488
 489   return options;
 490 }
 491 static CallOpenApplicationFunction FBSCallOpenApplicationFunction =
 492     CallBoardSystemServiceOpenApplication<
 493         FBSSystemService, FBSOpenApplicationErrorCode,
 494         FBSOpenApplicationErrorCodeNone, SetFBSError>;
 495 #endif // WITH_FBS
 496
 497 #if 0
 498 #define DEBUG_LOG(fmt, ...) printf(fmt, ##__VA_ARGS__)
 499 #else
 500 #define DEBUG_LOG(fmt, ...)
 501 #endif
 502
 503 #ifndef MACH_PROCESS_USE_POSIX_SPAWN
 504 #define MACH_PROCESS_USE_POSIX_SPAWN 1
 505 #endif
 506
 507 #ifndef _POSIX_SPAWN_DISABLE_ASLR
 508 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
 509 #endif
 510
 511
 512 MachProcess::MachProcess()
 513     : m_pid(0), m_cpu_type(0), m_child_stdin(-1), m_child_stdout(-1),
 514       m_child_stderr(-1), m_path(), m_args(), m_task(this),
 515       m_flags(eMachProcessFlagsNone), m_stdio_thread(0),
 516       m_stdio_mutex(PTHREAD_MUTEX_RECURSIVE), m_stdout_data(),
 517       m_profile_enabled(false), m_profile_interval_usec(0), m_profile_thread(0),
 518       m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE), m_profile_data(),
 519       m_profile_events(0, eMachProcessProfileCancel),
 520       m_thread_actions(), m_exception_messages(),
 521       m_exception_messages_mutex(PTHREAD_MUTEX_RECURSIVE), m_thread_list(),
 522       m_activities(), m_state(eStateUnloaded),
 523       m_state_mutex(PTHREAD_MUTEX_RECURSIVE), m_events(0, kAllEventsMask),
 524       m_private_events(0, kAllEventsMask), m_breakpoints(), m_watchpoints(),
 525       m_name_to_addr_callback(NULL), m_name_to_addr_baton(NULL),
 526       m_image_infos_callback(NULL), m_image_infos_baton(NULL),
 527       m_sent_interrupt_signo(0), m_auto_resume_signo(0), m_did_exec(false),
 528       m_dyld_process_info_create(nullptr),
 529       m_dyld_process_info_for_each_image(nullptr),
 530       m_dyld_process_info_release(nullptr),
 531       m_dyld_process_info_get_cache(nullptr) {
 532   m_dyld_process_info_create =
 533       (void *(*)(task_t task, uint64_t timestamp, kern_return_t * kernelError))
 534           dlsym(RTLD_DEFAULT, "_dyld_process_info_create");
 535   m_dyld_process_info_for_each_image =
 536       (void (*)(void *info, void (^)(uint64_t machHeaderAddress,
 537                                      const uuid_t uuid, const char *path)))
 538           dlsym(RTLD_DEFAULT, "_dyld_process_info_for_each_image");
 539   m_dyld_process_info_release =
 540       (void (*)(void *info))dlsym(RTLD_DEFAULT, "_dyld_process_info_release");
 541   m_dyld_process_info_get_cache = (void (*)(void *info, void *cacheInfo))dlsym(
 542       RTLD_DEFAULT, "_dyld_process_info_get_cache");
 543   m_dyld_process_info_get_platform = (uint32_t (*)(void *info))dlsym(
 544       RTLD_DEFAULT, "_dyld_process_info_get_platform");
 545
 546   DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
 547 }
 548
 549 MachProcess::~MachProcess() {
 550   DNBLogThreadedIf(LOG_PROCESS | LOG_VERBOSE, "%s", __PRETTY_FUNCTION__);
 551   Clear();
 552 }
 553
 554 pid_t MachProcess::SetProcessID(pid_t pid) {
 555   // Free any previous process specific data or resources
 556   Clear();
 557   // Set the current PID appropriately
 558   if (pid == 0)
 559     m_pid = ::getpid();
 560   else
 561     m_pid = pid;
 562   return m_pid; // Return actually PID in case a zero pid was passed in
 563 }
 564
 565 nub_state_t MachProcess::GetState() {
 566   // If any other threads access this we will need a mutex for it
 567   PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
 568   return m_state;
 569 }
 570
 571 const char *MachProcess::ThreadGetName(nub_thread_t tid) {
 572   return m_thread_list.GetName(tid);
 573 }
 574
 575 nub_state_t MachProcess::ThreadGetState(nub_thread_t tid) {
 576   return m_thread_list.GetState(tid);
 577 }
 578
 579 nub_size_t MachProcess::GetNumThreads() const {
 580   return m_thread_list.NumThreads();
 581 }
 582
 583 nub_thread_t MachProcess::GetThreadAtIndex(nub_size_t thread_idx) const {
 584   return m_thread_list.ThreadIDAtIndex(thread_idx);
 585 }
 586
 587 nub_thread_t
 588 MachProcess::GetThreadIDForMachPortNumber(thread_t mach_port_number) const {
 589   return m_thread_list.GetThreadIDByMachPortNumber(mach_port_number);
 590 }
 591
 592 nub_bool_t MachProcess::SyncThreadState(nub_thread_t tid) {
 593   MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
 594   if (!thread_sp)
 595     return false;
 596   kern_return_t kret = ::thread_abort_safely(thread_sp->MachPortNumber());
 597   DNBLogThreadedIf(LOG_THREAD, "thread = 0x%8.8" PRIx32
 598                                " calling thread_abort_safely (tid) => %u "
 599                                "(GetGPRState() for stop_count = %u)",
 600                    thread_sp->MachPortNumber(), kret,
 601                    thread_sp->Process()->StopCount());
 602
 603   if (kret == KERN_SUCCESS)
 604     return true;
 605   else
 606     return false;
 607 }
 608
 609 ThreadInfo::QoS MachProcess::GetRequestedQoS(nub_thread_t tid, nub_addr_t tsd,
 610                                              uint64_t dti_qos_class_index) {
 611   return m_thread_list.GetRequestedQoS(tid, tsd, dti_qos_class_index);
 612 }
 613
 614 nub_addr_t MachProcess::GetPThreadT(nub_thread_t tid) {
 615   return m_thread_list.GetPThreadT(tid);
 616 }
 617
 618 nub_addr_t MachProcess::GetDispatchQueueT(nub_thread_t tid) {
 619   return m_thread_list.GetDispatchQueueT(tid);
 620 }
 621
 622 nub_addr_t MachProcess::GetTSDAddressForThread(
 623     nub_thread_t tid, uint64_t plo_pthread_tsd_base_address_offset,
 624     uint64_t plo_pthread_tsd_base_offset, uint64_t plo_pthread_tsd_entry_size) {
 625   return m_thread_list.GetTSDAddressForThread(
 626       tid, plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset,
 627       plo_pthread_tsd_entry_size);
 628 }
 629
 630 MachProcess::DeploymentInfo
 631 MachProcess::GetDeploymentInfo(const struct load_command &lc,
 632                                uint64_t load_command_address,
 633                                bool is_executable) {
 634   DeploymentInfo info;
 635   uint32_t cmd = lc.cmd & ~LC_REQ_DYLD;
 636
 637   // Handle the older LC_VERSION load commands, which don't
 638   // distinguish between simulator and real hardware.
 639   auto handle_version_min = [&](char platform) {
 640     struct version_min_command vers_cmd;
 641     if (ReadMemory(load_command_address, sizeof(struct version_min_command),
 642                    &vers_cmd) != sizeof(struct version_min_command))
 643       return;
 644     info.platform = platform;
 645     info.major_version = vers_cmd.version >> 16;
 646     info.minor_version = (vers_cmd.version >> 8) & 0xffu;
 647     info.patch_version = vers_cmd.version & 0xffu;
 648
 649     // Disambiguate legacy simulator platforms.
 650 #if (defined(__x86_64__) || defined(__i386__))
 651     // If we are running on Intel macOS, it is safe to assume this is
 652     // really a back-deploying simulator binary.
 653     switch (info.platform) {
 654     case PLATFORM_IOS:
 655       info.platform = PLATFORM_IOSSIMULATOR;
 656       break;
 657     case PLATFORM_TVOS:
 658       info.platform = PLATFORM_TVOSSIMULATOR;
 659       break;
 660     case PLATFORM_WATCHOS:
 661       info.platform = PLATFORM_WATCHOSSIMULATOR;
 662       break;
 663     }
 664 #else
 665     // On an Apple Silicon macOS host, there is no ambiguity. The only
 666     // binaries that use legacy load commands are back-deploying
 667     // native iOS binaries. All simulator binaries use the newer,
 668     // unambiguous LC_BUILD_VERSION load commands.
 669 #endif
 670   };
 671
 672   switch (cmd) {
 673   case LC_VERSION_MIN_IPHONEOS:
 674     handle_version_min(PLATFORM_IOS);
 675     break;
 676   case LC_VERSION_MIN_MACOSX:
 677     handle_version_min(PLATFORM_MACOS);
 678     break;
 679   case LC_VERSION_MIN_TVOS:
 680     handle_version_min(PLATFORM_TVOS);
 681     break;
 682   case LC_VERSION_MIN_WATCHOS:
 683     handle_version_min(PLATFORM_WATCHOS);
 684     break;
 685 #if defined(LC_BUILD_VERSION)
 686   case LC_BUILD_VERSION: {
 687     struct build_version_command build_vers;
 688     if (ReadMemory(load_command_address, sizeof(struct build_version_command),
 689                    &build_vers) != sizeof(struct build_version_command))
 690       break;
 691     info.platform = build_vers.platform;
 692     info.major_version = build_vers.minos >> 16;
 693     info.minor_version = (build_vers.minos >> 8) & 0xffu;
 694     info.patch_version = build_vers.minos & 0xffu;
 695     break;
 696   }
 697 #endif
 698   }
 699
 700   // The xctest binary is a pure macOS binary but is launched with
 701   // DYLD_FORCE_PLATFORM=6. In that case, force the platform to
 702   // macCatalyst and use the macCatalyst version of the host OS
 703   // instead of the macOS deployment target.
 704   if (is_executable && GetPlatform() == PLATFORM_MACCATALYST) {
 705     info.platform = PLATFORM_MACCATALYST;
 706     std::string catalyst_version = GetMacCatalystVersionString();
 707     const char *major = catalyst_version.c_str();
 708     char *minor = nullptr;
 709     char *patch = nullptr;
 710     info.major_version = std::strtoul(major, &minor, 10);
 711     info.minor_version = 0;
 712     info.patch_version = 0;
 713     if (minor && *minor == '.') {
 714       info.minor_version = std::strtoul(++minor, &patch, 10);
 715       if (patch && *patch == '.')
 716         info.patch_version = std::strtoul(++patch, nullptr, 10);
 717     }
 718   }
 719
 720   return info;
 721 }
 722
 723 const char *MachProcess::GetPlatformString(unsigned char platform) {
 724   switch (platform) {
 725   case PLATFORM_MACOS:
 726     return "macosx";
 727   case PLATFORM_MACCATALYST:
 728     return "maccatalyst";
 729   case PLATFORM_IOS:
 730     return "ios";
 731   case PLATFORM_IOSSIMULATOR:
 732     return "iossimulator";
 733   case PLATFORM_TVOS:
 734     return "tvos";
 735   case PLATFORM_TVOSSIMULATOR:
 736     return "tvossimulator";
 737   case PLATFORM_WATCHOS:
 738     return "watchos";
 739   case PLATFORM_WATCHOSSIMULATOR:
 740     return "watchossimulator";
 741   case PLATFORM_BRIDGEOS:
 742     return "bridgeos";
 743   case PLATFORM_DRIVERKIT:
 744     return "driverkit";
 745   }
 746   return nullptr;
 747 }
 748
 749 // Given an address, read the mach-o header and load commands out of memory to
 750 // fill in
 751 // the mach_o_information "inf" object.
 752 //
 753 // Returns false if there was an error in reading this mach-o file header/load
 754 // commands.
 755
 756 bool MachProcess::GetMachOInformationFromMemory(
 757     uint32_t dyld_platform, nub_addr_t mach_o_header_addr, int wordsize,
 758     struct mach_o_information &inf) {
 759   uint64_t load_cmds_p;
 760   if (wordsize == 4) {
 761     struct mach_header header;
 762     if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header), &header) !=
 763         sizeof(struct mach_header)) {
 764       return false;
 765     }
 766     load_cmds_p = mach_o_header_addr + sizeof(struct mach_header);
 767     inf.mach_header.magic = header.magic;
 768     inf.mach_header.cputype = header.cputype;
 769     // high byte of cpusubtype is used for "capability bits", v.
 770     // CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
 771     inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
 772     inf.mach_header.filetype = header.filetype;
 773     inf.mach_header.ncmds = header.ncmds;
 774     inf.mach_header.sizeofcmds = header.sizeofcmds;
 775     inf.mach_header.flags = header.flags;
 776   } else {
 777     struct mach_header_64 header;
 778     if (ReadMemory(mach_o_header_addr, sizeof(struct mach_header_64),
 779                    &header) != sizeof(struct mach_header_64)) {
 780       return false;
 781     }
 782     load_cmds_p = mach_o_header_addr + sizeof(struct mach_header_64);
 783     inf.mach_header.magic = header.magic;
 784     inf.mach_header.cputype = header.cputype;
 785     // high byte of cpusubtype is used for "capability bits", v.
 786     // CPU_SUBTYPE_MASK, CPU_SUBTYPE_LIB64 in machine.h
 787     inf.mach_header.cpusubtype = header.cpusubtype & 0x00ffffff;
 788     inf.mach_header.filetype = header.filetype;
 789     inf.mach_header.ncmds = header.ncmds;
 790     inf.mach_header.sizeofcmds = header.sizeofcmds;
 791     inf.mach_header.flags = header.flags;
 792   }
 793   for (uint32_t j = 0; j < inf.mach_header.ncmds; j++) {
 794     struct load_command lc;
 795     if (ReadMemory(load_cmds_p, sizeof(struct load_command), &lc) !=
 796         sizeof(struct load_command)) {
 797       return false;
 798     }
 799     if (lc.cmd == LC_SEGMENT) {
 800       struct segment_command seg;
 801       if (ReadMemory(load_cmds_p, sizeof(struct segment_command), &seg) !=
 802           sizeof(struct segment_command)) {
 803         return false;
 804       }
 805       struct mach_o_segment this_seg;
 806       char name[17];
 807       ::memset(name, 0, sizeof(name));
 808       memcpy(name, seg.segname, sizeof(seg.segname));
 809       this_seg.name = name;
 810       this_seg.vmaddr = seg.vmaddr;
 811       this_seg.vmsize = seg.vmsize;
 812       this_seg.fileoff = seg.fileoff;
 813       this_seg.filesize = seg.filesize;
 814       this_seg.maxprot = seg.maxprot;
 815       this_seg.initprot = seg.initprot;
 816       this_seg.nsects = seg.nsects;
 817       this_seg.flags = seg.flags;
 818       inf.segments.push_back(this_seg);
 819       if (this_seg.name == "ExecExtraSuspend")
 820         m_task.TaskWillExecProcessesSuspended();
 821     }
 822     if (lc.cmd == LC_SEGMENT_64) {
 823       struct segment_command_64 seg;
 824       if (ReadMemory(load_cmds_p, sizeof(struct segment_command_64), &seg) !=
 825           sizeof(struct segment_command_64)) {
 826         return false;
 827       }
 828       struct mach_o_segment this_seg;
 829       char name[17];
 830       ::memset(name, 0, sizeof(name));
 831       memcpy(name, seg.segname, sizeof(seg.segname));
 832       this_seg.name = name;
 833       this_seg.vmaddr = seg.vmaddr;
 834       this_seg.vmsize = seg.vmsize;
 835       this_seg.fileoff = seg.fileoff;
 836       this_seg.filesize = seg.filesize;
 837       this_seg.maxprot = seg.maxprot;
 838       this_seg.initprot = seg.initprot;
 839       this_seg.nsects = seg.nsects;
 840       this_seg.flags = seg.flags;
 841       inf.segments.push_back(this_seg);
 842       if (this_seg.name == "ExecExtraSuspend")
 843         m_task.TaskWillExecProcessesSuspended();
 844     }
 845     if (lc.cmd == LC_UUID) {
 846       struct uuid_command uuidcmd;
 847       if (ReadMemory(load_cmds_p, sizeof(struct uuid_command), &uuidcmd) ==
 848           sizeof(struct uuid_command))
 849         uuid_copy(inf.uuid, uuidcmd.uuid);
 850     }
 851     if (DeploymentInfo deployment_info = GetDeploymentInfo(
 852             lc, load_cmds_p, inf.mach_header.filetype == MH_EXECUTE)) {
 853       const char *lc_platform = GetPlatformString(deployment_info.platform);
 854       if (dyld_platform != PLATFORM_MACCATALYST &&
 855           inf.min_version_os_name == "macosx") {
 856         // macCatalyst support.
 857         //
 858         // This the special case of "zippered" frameworks that have both
 859         // a PLATFORM_MACOS and a PLATFORM_MACCATALYST load command.
 860         //
 861         // When we are in this block, this is a binary with both
 862         // PLATFORM_MACOS and PLATFORM_MACCATALYST load commands and
 863         // the process is not running as PLATFORM_MACCATALYST. Stick
 864         // with the "macosx" load command that we've already
 865         // processed, ignore this one, which is presumed to be a
 866         // PLATFORM_MACCATALYST one.
 867       } else {
 868         inf.min_version_os_name = lc_platform;
 869         inf.min_version_os_version = "";
 870         inf.min_version_os_version +=
 871             std::to_string(deployment_info.major_version);
 872         inf.min_version_os_version += ".";
 873         inf.min_version_os_version +=
 874             std::to_string(deployment_info.minor_version);
 875         if (deployment_info.patch_version != 0) {
 876           inf.min_version_os_version += ".";
 877           inf.min_version_os_version +=
 878               std::to_string(deployment_info.patch_version);
 879         }
 880       }
 881     }
 882
 883     load_cmds_p += lc.cmdsize;
 884   }
 885   return true;
 886 }
 887
 888 // Given completely filled in array of binary_image_information structures,
 889 // create a JSONGenerator object
 890 // with all the details we want to send to lldb.
 891 JSONGenerator::ObjectSP MachProcess::FormatDynamicLibrariesIntoJSON(
 892     const std::vector<struct binary_image_information> &image_infos) {
 893
 894   JSONGenerator::ArraySP image_infos_array_sp(new JSONGenerator::Array());
 895
 896   const size_t image_count = image_infos.size();
 897
 898   for (size_t i = 0; i < image_count; i++) {
 899     JSONGenerator::DictionarySP image_info_dict_sp(
 900         new JSONGenerator::Dictionary());
 901     image_info_dict_sp->AddIntegerItem("load_address",
 902                                        image_infos[i].load_address);
 903     image_info_dict_sp->AddIntegerItem("mod_date", image_infos[i].mod_date);
 904     image_info_dict_sp->AddStringItem("pathname", image_infos[i].filename);
 905
 906     uuid_string_t uuidstr;
 907     uuid_unparse_upper(image_infos[i].macho_info.uuid, uuidstr);
 908     image_info_dict_sp->AddStringItem("uuid", uuidstr);
 909
 910     if (!image_infos[i].macho_info.min_version_os_name.empty() &&
 911         !image_infos[i].macho_info.min_version_os_version.empty()) {
 912       image_info_dict_sp->AddStringItem(
 913           "min_version_os_name", image_infos[i].macho_info.min_version_os_name);
 914       image_info_dict_sp->AddStringItem(
 915           "min_version_os_sdk",
 916           image_infos[i].macho_info.min_version_os_version);
 917     }
 918
 919     JSONGenerator::DictionarySP mach_header_dict_sp(
 920         new JSONGenerator::Dictionary());
 921     mach_header_dict_sp->AddIntegerItem(
 922         "magic", image_infos[i].macho_info.mach_header.magic);
 923     mach_header_dict_sp->AddIntegerItem(
 924         "cputype", (uint32_t)image_infos[i].macho_info.mach_header.cputype);
 925     mach_header_dict_sp->AddIntegerItem(
 926         "cpusubtype",
 927         (uint32_t)image_infos[i].macho_info.mach_header.cpusubtype);
 928     mach_header_dict_sp->AddIntegerItem(
 929         "filetype", image_infos[i].macho_info.mach_header.filetype);
 930     mach_header_dict_sp->AddIntegerItem ("flags",
 931                          image_infos[i].macho_info.mach_header.flags);
 932
 933     //          DynamicLoaderMacOSX doesn't currently need these fields, so
 934     //          don't send them.
 935     //            mach_header_dict_sp->AddIntegerItem ("ncmds",
 936     //            image_infos[i].macho_info.mach_header.ncmds);
 937     //            mach_header_dict_sp->AddIntegerItem ("sizeofcmds",
 938     //            image_infos[i].macho_info.mach_header.sizeofcmds);
 939     image_info_dict_sp->AddItem("mach_header", mach_header_dict_sp);
 940
 941     JSONGenerator::ArraySP segments_sp(new JSONGenerator::Array());
 942     for (size_t j = 0; j < image_infos[i].macho_info.segments.size(); j++) {
 943       JSONGenerator::DictionarySP segment_sp(new JSONGenerator::Dictionary());
 944       segment_sp->AddStringItem("name",
 945                                 image_infos[i].macho_info.segments[j].name);
 946       segment_sp->AddIntegerItem("vmaddr",
 947                                  image_infos[i].macho_info.segments[j].vmaddr);
 948       segment_sp->AddIntegerItem("vmsize",
 949                                  image_infos[i].macho_info.segments[j].vmsize);
 950       segment_sp->AddIntegerItem("fileoff",
 951                                  image_infos[i].macho_info.segments[j].fileoff);
 952       segment_sp->AddIntegerItem(
 953           "filesize", image_infos[i].macho_info.segments[j].filesize);
 954       segment_sp->AddIntegerItem("maxprot",
 955                                  image_infos[i].macho_info.segments[j].maxprot);
 956
 957       //              DynamicLoaderMacOSX doesn't currently need these fields,
 958       //              so don't send them.
 959       //                segment_sp->AddIntegerItem ("initprot",
 960       //                image_infos[i].macho_info.segments[j].initprot);
 961       //                segment_sp->AddIntegerItem ("nsects",
 962       //                image_infos[i].macho_info.segments[j].nsects);
 963       //                segment_sp->AddIntegerItem ("flags",
 964       //                image_infos[i].macho_info.segments[j].flags);
 965       segments_sp->AddItem(segment_sp);
 966     }
 967     image_info_dict_sp->AddItem("segments", segments_sp);
 968
 969     image_infos_array_sp->AddItem(image_info_dict_sp);
 970   }
 971
 972   JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
 973   ;
 974   reply_sp->AddItem("images", image_infos_array_sp);
 975
 976   return reply_sp;
 977 }
 978
 979 // Get the shared library information using the old (pre-macOS 10.12, pre-iOS
 980 // 10, pre-tvOS 10, pre-watchOS 3)
 981 // code path.  We'll be given the address of an array of structures in the form
 982 // {void* load_addr, void* mod_date, void* pathname}
 983 //
 984 // In macOS 10.12 etc and newer, we'll use SPI calls into dyld to gather this
 985 // information.
 986 JSONGenerator::ObjectSP MachProcess::GetLoadedDynamicLibrariesInfos(
 987     nub_process_t pid, nub_addr_t image_list_address, nub_addr_t image_count) {
 988   JSONGenerator::DictionarySP reply_sp;
 989
 990   int pointer_size = GetInferiorAddrSize(pid);
 991
 992   std::vector<struct binary_image_information> image_infos;
 993   size_t image_infos_size = image_count * 3 * pointer_size;
 994
 995   uint8_t *image_info_buf = (uint8_t *)malloc(image_infos_size);
 996   if (image_info_buf == NULL) {
 997     return reply_sp;
 998   }
 999     if (ReadMemory(image_list_address, image_infos_size, image_info_buf) !=
1000         image_infos_size) {
1001       return reply_sp;
1002     }
1003
1004     ////  First the image_infos array with (load addr, pathname, mod date)
1005     ///tuples
1006
1007     for (size_t i = 0; i < image_count; i++) {
1008       struct binary_image_information info;
1009       nub_addr_t pathname_address;
1010       if (pointer_size == 4) {
1011         uint32_t load_address_32;
1012         uint32_t pathname_address_32;
1013         uint32_t mod_date_32;
1014         ::memcpy(&load_address_32, image_info_buf + (i * 3 * pointer_size), 4);
1015         ::memcpy(&pathname_address_32,
1016                  image_info_buf + (i * 3 * pointer_size) + pointer_size, 4);
1017         ::memcpy(&mod_date_32, image_info_buf + (i * 3 * pointer_size) +
1018                                    pointer_size + pointer_size,
1019                  4);
1020         info.load_address = load_address_32;
1021         info.mod_date = mod_date_32;
1022         pathname_address = pathname_address_32;
1023       } else {
1024         uint64_t load_address_64;
1025         uint64_t pathname_address_64;
1026         uint64_t mod_date_64;
1027         ::memcpy(&load_address_64, image_info_buf + (i * 3 * pointer_size), 8);
1028         ::memcpy(&pathname_address_64,
1029                  image_info_buf + (i * 3 * pointer_size) + pointer_size, 8);
1030         ::memcpy(&mod_date_64, image_info_buf + (i * 3 * pointer_size) +
1031                                    pointer_size + pointer_size,
1032                  8);
1033         info.load_address = load_address_64;
1034         info.mod_date = mod_date_64;
1035         pathname_address = pathname_address_64;
1036       }
1037       char strbuf[17];
1038       info.filename = "";
1039       uint64_t pathname_ptr = pathname_address;
1040       bool still_reading = true;
1041       while (still_reading &&
1042              ReadMemory(pathname_ptr, sizeof(strbuf) - 1, strbuf) ==
1043                  sizeof(strbuf) - 1) {
1044         strbuf[sizeof(strbuf) - 1] = '\0';
1045         info.filename += strbuf;
1046         pathname_ptr += sizeof(strbuf) - 1;
1047         // Stop if we found nul byte indicating the end of the string
1048         for (size_t i = 0; i < sizeof(strbuf) - 1; i++) {
1049           if (strbuf[i] == '\0') {
1050             still_reading = false;
1051             break;
1052           }
1053         }
1054       }
1055       uuid_clear(info.macho_info.uuid);
1056       image_infos.push_back(info);
1057     }
1058     if (image_infos.size() == 0) {
1059       return reply_sp;
1060     }
1061
1062     free(image_info_buf);
1063
1064     ////  Second, read the mach header / load commands for all the dylibs
1065
1066     for (size_t i = 0; i < image_count; i++) {
1067       // The SPI to provide platform is not available on older systems.
1068       uint32_t platform = 0;
1069       if (!GetMachOInformationFromMemory(platform,
1070                                          image_infos[i].load_address,
1071                                          pointer_size,
1072                                          image_infos[i].macho_info)) {
1073         return reply_sp;
1074       }
1075     }
1076
1077     ////  Third, format all of the above in the JSONGenerator object.
1078
1079     return FormatDynamicLibrariesIntoJSON(image_infos);
1080
1081   return reply_sp;
1082 }
1083
1084 /// From dyld SPI header dyld_process_info.h
1085 typedef void *dyld_process_info;
1086 struct dyld_process_cache_info {
1087   /// UUID of cache used by process.
1088   uuid_t cacheUUID;
1089   /// Load address of dyld shared cache.
1090   uint64_t cacheBaseAddress;
1091   /// Process is running without a dyld cache.
1092   bool noCache;
1093   /// Process is using a private copy of its dyld cache.
1094   bool privateCache;
1095 };
1096
1097 uint32_t MachProcess::GetPlatform() {
1098   if (m_platform == 0)
1099     m_platform = MachProcess::GetProcessPlatformViaDYLDSPI();
1100   return m_platform;
1101 }
1102
1103 uint32_t MachProcess::GetProcessPlatformViaDYLDSPI() {
1104   kern_return_t kern_ret;
1105   uint32_t platform = 0;
1106   if (m_dyld_process_info_create) {
1107     dyld_process_info info =
1108         m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
1109     if (info) {
1110       if (m_dyld_process_info_get_platform)
1111         platform = m_dyld_process_info_get_platform(info);
1112       m_dyld_process_info_release(info);
1113     }
1114   }
1115   return platform;
1116 }
1117
1118 void MachProcess::GetAllLoadedBinariesViaDYLDSPI(
1119     std::vector<struct binary_image_information> &image_infos) {
1120   kern_return_t kern_ret;
1121   if (m_dyld_process_info_create) {
1122     dyld_process_info info =
1123         m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
1124     if (info) {
1125       m_dyld_process_info_for_each_image(
1126           info,
1127           ^(uint64_t mach_header_addr, const uuid_t uuid, const char *path) {
1128             struct binary_image_information image;
1129             image.filename = path;
1130             uuid_copy(image.macho_info.uuid, uuid);
1131             image.load_address = mach_header_addr;
1132             image_infos.push_back(image);
1133           });
1134       m_dyld_process_info_release(info);
1135     }
1136   }
1137 }
1138
1139 // Fetch information about all shared libraries using the dyld SPIs that exist
1140 // in
1141 // macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
1142 JSONGenerator::ObjectSP
1143 MachProcess::GetAllLoadedLibrariesInfos(nub_process_t pid) {
1144   JSONGenerator::DictionarySP reply_sp;
1145
1146   int pointer_size = GetInferiorAddrSize(pid);
1147   std::vector<struct binary_image_information> image_infos;
1148   GetAllLoadedBinariesViaDYLDSPI(image_infos);
1149   uint32_t platform = GetPlatform();
1150   const size_t image_count = image_infos.size();
1151   for (size_t i = 0; i < image_count; i++) {
1152     GetMachOInformationFromMemory(platform, image_infos[i].load_address,
1153                                   pointer_size, image_infos[i].macho_info);
1154   }
1155     return FormatDynamicLibrariesIntoJSON(image_infos);
1156 }
1157
1158 // Fetch information about the shared libraries at the given load addresses
1159 // using the
1160 // dyld SPIs that exist in macOS 10.12, iOS 10, tvOS 10, watchOS 3 and newer.
1161 JSONGenerator::ObjectSP MachProcess::GetLibrariesInfoForAddresses(
1162     nub_process_t pid, std::vector<uint64_t> &macho_addresses) {
1163   JSONGenerator::DictionarySP reply_sp;
1164
1165   int pointer_size = GetInferiorAddrSize(pid);
1166
1167   std::vector<struct binary_image_information> all_image_infos;
1168   GetAllLoadedBinariesViaDYLDSPI(all_image_infos);
1169   uint32_t platform = GetPlatform();
1170
1171   std::vector<struct binary_image_information> image_infos;
1172   const size_t macho_addresses_count = macho_addresses.size();
1173   const size_t all_image_infos_count = all_image_infos.size();
1174   for (size_t i = 0; i < macho_addresses_count; i++) {
1175     for (size_t j = 0; j < all_image_infos_count; j++) {
1176       if (all_image_infos[j].load_address == macho_addresses[i]) {
1177         image_infos.push_back(all_image_infos[j]);
1178       }
1179     }
1180   }
1181
1182     const size_t image_infos_count = image_infos.size();
1183     for (size_t i = 0; i < image_infos_count; i++) {
1184       GetMachOInformationFromMemory(platform,
1185                                     image_infos[i].load_address, pointer_size,
1186                                     image_infos[i].macho_info);
1187     }
1188     return FormatDynamicLibrariesIntoJSON(image_infos);
1189 }
1190
1191 // From dyld's internal podyld_process_info.h:
1192
1193 JSONGenerator::ObjectSP MachProcess::GetSharedCacheInfo(nub_process_t pid) {
1194   JSONGenerator::DictionarySP reply_sp(new JSONGenerator::Dictionary());
1195
1196   kern_return_t kern_ret;
1197   if (m_dyld_process_info_create && m_dyld_process_info_get_cache) {
1198     dyld_process_info info =
1199         m_dyld_process_info_create(m_task.TaskPort(), 0, &kern_ret);
1200     if (info) {
1201       struct dyld_process_cache_info shared_cache_info;
1202       m_dyld_process_info_get_cache(info, &shared_cache_info);
1203
1204       reply_sp->AddIntegerItem("shared_cache_base_address",
1205                                shared_cache_info.cacheBaseAddress);
1206
1207       uuid_string_t uuidstr;
1208       uuid_unparse_upper(shared_cache_info.cacheUUID, uuidstr);
1209       reply_sp->AddStringItem("shared_cache_uuid", uuidstr);
1210
1211       reply_sp->AddBooleanItem("no_shared_cache", shared_cache_info.noCache);
1212       reply_sp->AddBooleanItem("shared_cache_private_cache",
1213                                shared_cache_info.privateCache);
1214
1215       m_dyld_process_info_release(info);
1216     }
1217   }
1218   return reply_sp;
1219 }
1220
1221 nub_thread_t MachProcess::GetCurrentThread() {
1222   return m_thread_list.CurrentThreadID();
1223 }
1224
1225 nub_thread_t MachProcess::GetCurrentThreadMachPort() {
1226   return m_thread_list.GetMachPortNumberByThreadID(
1227       m_thread_list.CurrentThreadID());
1228 }
1229
1230 nub_thread_t MachProcess::SetCurrentThread(nub_thread_t tid) {
1231   return m_thread_list.SetCurrentThread(tid);
1232 }
1233
1234 bool MachProcess::GetThreadStoppedReason(nub_thread_t tid,
1235                                          struct DNBThreadStopInfo *stop_info) {
1236   if (m_thread_list.GetThreadStoppedReason(tid, stop_info)) {
1237     if (m_did_exec)
1238       stop_info->reason = eStopTypeExec;
1239     return true;
1240   }
1241   return false;
1242 }
1243
1244 void MachProcess::DumpThreadStoppedReason(nub_thread_t tid) const {
1245   return m_thread_list.DumpThreadStoppedReason(tid);
1246 }
1247
1248 const char *MachProcess::GetThreadInfo(nub_thread_t tid) const {
1249   return m_thread_list.GetThreadInfo(tid);
1250 }
1251
1252 uint32_t MachProcess::GetCPUType() {
1253   if (m_cpu_type == 0 && m_pid != 0)
1254     m_cpu_type = MachProcess::GetCPUTypeForLocalProcess(m_pid);
1255   return m_cpu_type;
1256 }
1257
1258 const DNBRegisterSetInfo *
1259 MachProcess::GetRegisterSetInfo(nub_thread_t tid,
1260                                 nub_size_t *num_reg_sets) const {
1261   MachThreadSP thread_sp(m_thread_list.GetThreadByID(tid));
1262   if (thread_sp) {
1263     DNBArchProtocol *arch = thread_sp->GetArchProtocol();
1264     if (arch)
1265       return arch->GetRegisterSetInfo(num_reg_sets);
1266   }
1267   *num_reg_sets = 0;
1268   return NULL;
1269 }
1270
1271 bool MachProcess::GetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
1272                                    DNBRegisterValue *value) const {
1273   return m_thread_list.GetRegisterValue(tid, set, reg, value);
1274 }
1275
1276 bool MachProcess::SetRegisterValue(nub_thread_t tid, uint32_t set, uint32_t reg,
1277                                    const DNBRegisterValue *value) const {
1278   return m_thread_list.SetRegisterValue(tid, set, reg, value);
1279 }
1280
1281 void MachProcess::SetState(nub_state_t new_state) {
1282   // If any other threads access this we will need a mutex for it
1283   uint32_t event_mask = 0;
1284
1285   // Scope for mutex locker
1286   {
1287     PTHREAD_MUTEX_LOCKER(locker, m_state_mutex);
1288     const nub_state_t old_state = m_state;
1289
1290     if (old_state == eStateExited) {
1291       DNBLogThreadedIf(LOG_PROCESS, "MachProcess::SetState(%s) ignoring new "
1292                                     "state since current state is exited",
1293                        DNBStateAsString(new_state));
1294     } else if (old_state == new_state) {
1295       DNBLogThreadedIf(
1296           LOG_PROCESS,
1297           "MachProcess::SetState(%s) ignoring redundant state change...",
1298           DNBStateAsString(new_state));
1299     } else {
1300       if (NUB_STATE_IS_STOPPED(new_state))
1301         event_mask = eEventProcessStoppedStateChanged;
1302       else
1303         event_mask = eEventProcessRunningStateChanged;
1304
1305       DNBLogThreadedIf(
1306           LOG_PROCESS, "MachProcess::SetState(%s) upating state (previous "
1307                        "state was %s), event_mask = 0x%8.8x",
1308           DNBStateAsString(new_state), DNBStateAsString(old_state), event_mask);
1309
1310       m_state = new_state;
1311       if (new_state == eStateStopped)
1312         m_stop_count++;
1313     }
1314   }
1315
1316   if (event_mask != 0) {
1317     m_events.SetEvents(event_mask);
1318     m_private_events.SetEvents(event_mask);
1319     if (event_mask == eEventProcessStoppedStateChanged)
1320       m_private_events.ResetEvents(eEventProcessRunningStateChanged);
1321     else
1322       m_private_events.ResetEvents(eEventProcessStoppedStateChanged);
1323
1324     // Wait for the event bit to reset if a reset ACK is requested
1325     m_events.WaitForResetAck(event_mask);
1326   }
1327 }
1328
1329 void MachProcess::Clear(bool detaching) {
1330   // Clear any cached thread list while the pid and task are still valid
1331
1332   m_task.Clear();
1333   m_platform = 0;
1334   // Now clear out all member variables
1335   m_pid = INVALID_NUB_PROCESS;
1336   if (!detaching)
1337     CloseChildFileDescriptors();
1338
1339   m_path.clear();
1340   m_args.clear();
1341   SetState(eStateUnloaded);
1342   m_flags = eMachProcessFlagsNone;
1343   m_stop_count = 0;
1344   m_thread_list.Clear();
1345   {
1346     PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
1347     m_exception_messages.clear();
1348   }
1349   m_activities.Clear();
1350   StopProfileThread();
1351 }
1352
1353 bool MachProcess::StartSTDIOThread() {
1354   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
1355   // Create the thread that watches for the child STDIO
1356   return ::pthread_create(&m_stdio_thread, NULL, MachProcess::STDIOThread,
1357                           this) == 0;
1358 }
1359
1360 void MachProcess::SetEnableAsyncProfiling(bool enable, uint64_t interval_usec,
1361                                           DNBProfileDataScanType scan_type) {
1362   m_profile_enabled = enable;
1363   m_profile_interval_usec = static_cast<useconds_t>(interval_usec);
1364   m_profile_scan_type = scan_type;
1365
1366   if (m_profile_enabled && (m_profile_thread == NULL)) {
1367     StartProfileThread();
1368   } else if (!m_profile_enabled && m_profile_thread) {
1369     StopProfileThread();
1370   }
1371 }
1372
1373 void MachProcess::StopProfileThread() {
1374   if (m_profile_thread == NULL)
1375     return;
1376   m_profile_events.SetEvents(eMachProcessProfileCancel);
1377   pthread_join(m_profile_thread, NULL);
1378   m_profile_thread = NULL;
1379   m_profile_events.ResetEvents(eMachProcessProfileCancel);
1380 }
1381
1382 bool MachProcess::StartProfileThread() {
1383   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s ( )", __FUNCTION__);
1384   // Create the thread that profiles the inferior and reports back if enabled
1385   return ::pthread_create(&m_profile_thread, NULL, MachProcess::ProfileThread,
1386                           this) == 0;
1387 }
1388
1389 nub_addr_t MachProcess::LookupSymbol(const char *name, const char *shlib) {
1390   if (m_name_to_addr_callback != NULL && name && name[0])
1391     return m_name_to_addr_callback(ProcessID(), name, shlib,
1392                                    m_name_to_addr_baton);
1393   return INVALID_NUB_ADDRESS;
1394 }
1395
1396 bool MachProcess::Resume(const DNBThreadResumeActions &thread_actions) {
1397   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Resume ()");
1398   nub_state_t state = GetState();
1399
1400   if (CanResume(state)) {
1401     m_thread_actions = thread_actions;
1402     PrivateResume();
1403     return true;
1404   } else if (state == eStateRunning) {
1405     DNBLog("Resume() - task 0x%x is already running, ignoring...",
1406            m_task.TaskPort());
1407     return true;
1408   }
1409   DNBLog("Resume() - task 0x%x has state %s, can't continue...",
1410          m_task.TaskPort(), DNBStateAsString(state));
1411   return false;
1412 }
1413
1414 bool MachProcess::Kill(const struct timespec *timeout_abstime) {
1415   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill ()");
1416   nub_state_t state = DoSIGSTOP(true, false, NULL);
1417   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Kill() DoSIGSTOP() state = %s",
1418                    DNBStateAsString(state));
1419   errno = 0;
1420   DNBLog("Sending ptrace PT_KILL to terminate inferior process pid %d.", m_pid);
1421   ::ptrace(PT_KILL, m_pid, 0, 0);
1422   DNBError err;
1423   err.SetErrorToErrno();
1424   if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail()) {
1425     err.LogThreaded("MachProcess::Kill() DoSIGSTOP() ::ptrace "
1426             "(PT_KILL, pid=%u, 0, 0) => 0x%8.8x (%s)",
1427             m_pid, err.Status(), err.AsString());
1428   }
1429   m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
1430   PrivateResume();
1431
1432   // Try and reap the process without touching our m_events since
1433   // we want the code above this to still get the eStateExited event
1434   const uint32_t reap_timeout_usec =
1435       1000000; // Wait 1 second and try to reap the process
1436   const uint32_t reap_interval_usec = 10000; //
1437   uint32_t reap_time_elapsed;
1438   for (reap_time_elapsed = 0; reap_time_elapsed < reap_timeout_usec;
1439        reap_time_elapsed += reap_interval_usec) {
1440     if (GetState() == eStateExited)
1441       break;
1442     usleep(reap_interval_usec);
1443   }
1444   DNBLog("Waited %u ms for process to be reaped (state = %s)",
1445          reap_time_elapsed / 1000, DNBStateAsString(GetState()));
1446   return true;
1447 }
1448
1449 bool MachProcess::Interrupt() {
1450   nub_state_t state = GetState();
1451   if (IsRunning(state)) {
1452     if (m_sent_interrupt_signo == 0) {
1453       m_sent_interrupt_signo = SIGSTOP;
1454       if (Signal(m_sent_interrupt_signo)) {
1455         DNBLogThreadedIf(
1456             LOG_PROCESS,
1457             "MachProcess::Interrupt() - sent %i signal to interrupt process",
1458             m_sent_interrupt_signo);
1459         return true;
1460       } else {
1461         m_sent_interrupt_signo = 0;
1462         DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - failed to "
1463                                       "send %i signal to interrupt process",
1464                          m_sent_interrupt_signo);
1465       }
1466     } else {
1467       DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - previously "
1468                                     "sent an interrupt signal %i that hasn't "
1469                                     "been received yet, interrupt aborted",
1470                        m_sent_interrupt_signo);
1471     }
1472   } else {
1473     DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - process already "
1474                                   "stopped, no interrupt sent");
1475   }
1476   return false;
1477 }
1478
1479 bool MachProcess::Signal(int signal, const struct timespec *timeout_abstime) {
1480   DNBLogThreadedIf(LOG_PROCESS,
1481                    "MachProcess::Signal (signal = %d, timeout = %p)", signal,
1482                    static_cast<const void *>(timeout_abstime));
1483   nub_state_t state = GetState();
1484   if (::kill(ProcessID(), signal) == 0) {
1485     // If we were running and we have a timeout, wait for the signal to stop
1486     if (IsRunning(state) && timeout_abstime) {
1487       DNBLogThreadedIf(LOG_PROCESS,
1488                        "MachProcess::Signal (signal = %d, timeout "
1489                        "= %p) waiting for signal to stop "
1490                        "process...",
1491                        signal, static_cast<const void *>(timeout_abstime));
1492       m_private_events.WaitForSetEvents(eEventProcessStoppedStateChanged,
1493                                         timeout_abstime);
1494       state = GetState();
1495       DNBLogThreadedIf(
1496           LOG_PROCESS,
1497           "MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal,
1498           static_cast<const void *>(timeout_abstime), DNBStateAsString(state));
1499       return !IsRunning(state);
1500     }
1501     DNBLogThreadedIf(
1502         LOG_PROCESS,
1503         "MachProcess::Signal (signal = %d, timeout = %p) not waiting...",
1504         signal, static_cast<const void *>(timeout_abstime));
1505     return true;
1506   }
1507   DNBError err(errno, DNBError::POSIX);
1508   err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal);
1509   return false;
1510 }
1511
1512 bool MachProcess::SendEvent(const char *event, DNBError &send_err) {
1513   DNBLogThreadedIf(LOG_PROCESS,
1514                    "MachProcess::SendEvent (event = %s) to pid: %d", event,
1515                    m_pid);
1516   if (m_pid == INVALID_NUB_PROCESS)
1517     return false;
1518 // FIXME: Shouldn't we use the launch flavor we were started with?
1519 #if defined(WITH_FBS) || defined(WITH_BKS)
1520   return BoardServiceSendEvent(event, send_err);
1521 #endif
1522   return true;
1523 }
1524
1525 nub_state_t MachProcess::DoSIGSTOP(bool clear_bps_and_wps, bool allow_running,
1526                                    uint32_t *thread_idx_ptr) {
1527   nub_state_t state = GetState();
1528   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::DoSIGSTOP() state = %s",
1529                    DNBStateAsString(state));
1530
1531   if (!IsRunning(state)) {
1532     if (clear_bps_and_wps) {
1533       DisableAllBreakpoints(true);
1534       DisableAllWatchpoints(true);
1535       clear_bps_and_wps = false;
1536     }
1537
1538     // If we already have a thread stopped due to a SIGSTOP, we don't have
1539     // to do anything...
1540     uint32_t thread_idx =
1541         m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
1542     if (thread_idx_ptr)
1543       *thread_idx_ptr = thread_idx;
1544     if (thread_idx != UINT32_MAX)
1545       return GetState();
1546
1547     // No threads were stopped with a SIGSTOP, we need to run and halt the
1548     // process with a signal
1549     DNBLogThreadedIf(LOG_PROCESS,
1550                      "MachProcess::DoSIGSTOP() state = %s -- resuming process",
1551                      DNBStateAsString(state));
1552     if (allow_running)
1553       m_thread_actions = DNBThreadResumeActions(eStateRunning, 0);
1554     else
1555       m_thread_actions = DNBThreadResumeActions(eStateSuspended, 0);
1556
1557     PrivateResume();
1558
1559     // Reset the event that says we were indeed running
1560     m_events.ResetEvents(eEventProcessRunningStateChanged);
1561     state = GetState();
1562   }
1563
1564   // We need to be stopped in order to be able to detach, so we need
1565   // to send ourselves a SIGSTOP
1566
1567   DNBLogThreadedIf(LOG_PROCESS,
1568                    "MachProcess::DoSIGSTOP() state = %s -- sending SIGSTOP",
1569                    DNBStateAsString(state));
1570   struct timespec sigstop_timeout;
1571   DNBTimer::OffsetTimeOfDay(&sigstop_timeout, 2, 0);
1572   Signal(SIGSTOP, &sigstop_timeout);
1573   if (clear_bps_and_wps) {
1574     DisableAllBreakpoints(true);
1575     DisableAllWatchpoints(true);
1576     // clear_bps_and_wps = false;
1577   }
1578   uint32_t thread_idx =
1579       m_thread_list.GetThreadIndexForThreadStoppedWithSignal(SIGSTOP);
1580   if (thread_idx_ptr)
1581     *thread_idx_ptr = thread_idx;
1582   return GetState();
1583 }
1584
1585 bool MachProcess::Detach() {
1586   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach()");
1587
1588   uint32_t thread_idx = UINT32_MAX;
1589   nub_state_t state = DoSIGSTOP(true, true, &thread_idx);
1590   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Detach() DoSIGSTOP() returned %s",
1591                    DNBStateAsString(state));
1592
1593   {
1594     m_thread_actions.Clear();
1595     m_activities.Clear();
1596     DNBThreadResumeAction thread_action;
1597     thread_action.tid = m_thread_list.ThreadIDAtIndex(thread_idx);
1598     thread_action.state = eStateRunning;
1599     thread_action.signal = -1;
1600     thread_action.addr = INVALID_NUB_ADDRESS;
1601
1602     m_thread_actions.Append(thread_action);
1603     m_thread_actions.SetDefaultThreadActionIfNeeded(eStateRunning, 0);
1604
1605     PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
1606
1607     ReplyToAllExceptions();
1608   }
1609
1610   m_task.ShutDownExcecptionThread();
1611
1612   // Detach from our process
1613   errno = 0;
1614   nub_process_t pid = m_pid;
1615   int ret = ::ptrace(PT_DETACH, pid, (caddr_t)1, 0);
1616   DNBError err(errno, DNBError::POSIX);
1617   if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
1618     err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
1619
1620   // Resume our task
1621   m_task.Resume();
1622
1623   // NULL our task out as we have already restored all exception ports
1624   m_task.Clear();
1625   m_platform = 0;
1626
1627   // Clear out any notion of the process we once were
1628   const bool detaching = true;
1629   Clear(detaching);
1630
1631   SetState(eStateDetached);
1632
1633   return true;
1634 }
1635
1636 //----------------------------------------------------------------------
1637 // ReadMemory from the MachProcess level will always remove any software
1638 // breakpoints from the memory buffer before returning. If you wish to
1639 // read memory and see those traps, read from the MachTask
1640 // (m_task.ReadMemory()) as that version will give you what is actually
1641 // in inferior memory.
1642 //----------------------------------------------------------------------
1643 nub_size_t MachProcess::ReadMemory(nub_addr_t addr, nub_size_t size,
1644                                    void *buf) {
1645   // We need to remove any current software traps (enabled software
1646   // breakpoints) that we may have placed in our tasks memory.
1647
1648   // First just read the memory as is
1649   nub_size_t bytes_read = m_task.ReadMemory(addr, size, buf);
1650
1651   // Then place any opcodes that fall into this range back into the buffer
1652   // before we return this to callers.
1653   if (bytes_read > 0)
1654     m_breakpoints.RemoveTrapsFromBuffer(addr, bytes_read, buf);
1655   return bytes_read;
1656 }
1657
1658 //----------------------------------------------------------------------
1659 // WriteMemory from the MachProcess level will always write memory around
1660 // any software breakpoints. Any software breakpoints will have their
1661 // opcodes modified if they are enabled. Any memory that doesn't overlap
1662 // with software breakpoints will be written to. If you wish to write to
1663 // inferior memory without this interference, then write to the MachTask
1664 // (m_task.WriteMemory()) as that version will always modify inferior
1665 // memory.
1666 //----------------------------------------------------------------------
1667 nub_size_t MachProcess::WriteMemory(nub_addr_t addr, nub_size_t size,
1668                                     const void *buf) {
1669   // We need to write any data that would go where any current software traps
1670   // (enabled software breakpoints) any software traps (breakpoints) that we
1671   // may have placed in our tasks memory.
1672
1673   std::vector<DNBBreakpoint *> bps;
1674
1675   const size_t num_bps =
1676       m_breakpoints.FindBreakpointsThatOverlapRange(addr, size, bps);
1677   if (num_bps == 0)
1678     return m_task.WriteMemory(addr, size, buf);
1679
1680   nub_size_t bytes_written = 0;
1681   nub_addr_t intersect_addr;
1682   nub_size_t intersect_size;
1683   nub_size_t opcode_offset;
1684   const uint8_t *ubuf = (const uint8_t *)buf;
1685
1686   for (size_t i = 0; i < num_bps; ++i) {
1687     DNBBreakpoint *bp = bps[i];
1688
1689     const bool intersects = bp->IntersectsRange(
1690         addr, size, &intersect_addr, &intersect_size, &opcode_offset);
1691     UNUSED_IF_ASSERT_DISABLED(intersects);
1692     assert(intersects);
1693     assert(addr <= intersect_addr && intersect_addr < addr + size);
1694     assert(addr < intersect_addr + intersect_size &&
1695            intersect_addr + intersect_size <= addr + size);
1696     assert(opcode_offset + intersect_size <= bp->ByteSize());
1697
1698     // Check for bytes before this breakpoint
1699     const nub_addr_t curr_addr = addr + bytes_written;
1700     if (intersect_addr > curr_addr) {
1701       // There are some bytes before this breakpoint that we need to
1702       // just write to memory
1703       nub_size_t curr_size = intersect_addr - curr_addr;
1704       nub_size_t curr_bytes_written =
1705           m_task.WriteMemory(curr_addr, curr_size, ubuf + bytes_written);
1706       bytes_written += curr_bytes_written;
1707       if (curr_bytes_written != curr_size) {
1708         // We weren't able to write all of the requested bytes, we
1709         // are done looping and will return the number of bytes that
1710         // we have written so far.
1711         break;
1712       }
1713     }
1714
1715     // Now write any bytes that would cover up any software breakpoints
1716     // directly into the breakpoint opcode buffer
1717     ::memcpy(bp->SavedOpcodeBytes() + opcode_offset, ubuf + bytes_written,
1718              intersect_size);
1719     bytes_written += intersect_size;
1720   }
1721
1722   // Write any remaining bytes after the last breakpoint if we have any left
1723   if (bytes_written < size)
1724     bytes_written += m_task.WriteMemory(
1725         addr + bytes_written, size - bytes_written, ubuf + bytes_written);
1726
1727   return bytes_written;
1728 }
1729
1730 void MachProcess::ReplyToAllExceptions() {
1731   PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
1732   if (!m_exception_messages.empty()) {
1733     MachException::Message::iterator pos;
1734     MachException::Message::iterator begin = m_exception_messages.begin();
1735     MachException::Message::iterator end = m_exception_messages.end();
1736     for (pos = begin; pos != end; ++pos) {
1737       DNBLogThreadedIf(LOG_EXCEPTIONS, "Replying to exception %u...",
1738                        (uint32_t)std::distance(begin, pos));
1739       int thread_reply_signal = 0;
1740
1741       nub_thread_t tid =
1742           m_thread_list.GetThreadIDByMachPortNumber(pos->state.thread_port);
1743       const DNBThreadResumeAction *action = NULL;
1744       if (tid != INVALID_NUB_THREAD) {
1745         action = m_thread_actions.GetActionForThread(tid, false);
1746       }
1747
1748       if (action) {
1749         thread_reply_signal = action->signal;
1750         if (thread_reply_signal)
1751           m_thread_actions.SetSignalHandledForThread(tid);
1752       }
1753
1754       DNBError err(pos->Reply(this, thread_reply_signal));
1755       if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
1756         err.LogThreadedIfError("Error replying to exception");
1757     }
1758
1759     // Erase all exception message as we should have used and replied
1760     // to them all already.
1761     m_exception_messages.clear();
1762   }
1763 }
1764 void MachProcess::PrivateResume() {
1765   PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
1766
1767   m_auto_resume_signo = m_sent_interrupt_signo;
1768   if (m_auto_resume_signo)
1769     DNBLogThreadedIf(LOG_PROCESS, "MachProcess::PrivateResume() - task 0x%x "
1770                                   "resuming (with unhandled interrupt signal "
1771                                   "%i)...",
1772                      m_task.TaskPort(), m_auto_resume_signo);
1773   else
1774     DNBLogThreadedIf(LOG_PROCESS,
1775                      "MachProcess::PrivateResume() - task 0x%x resuming...",
1776                      m_task.TaskPort());
1777
1778   ReplyToAllExceptions();
1779   //    bool stepOverBreakInstruction = step;
1780
1781   // Let the thread prepare to resume and see if any threads want us to
1782   // step over a breakpoint instruction (ProcessWillResume will modify
1783   // the value of stepOverBreakInstruction).
1784   m_thread_list.ProcessWillResume(this, m_thread_actions);
1785
1786   // Set our state accordingly
1787   if (m_thread_actions.NumActionsWithState(eStateStepping))
1788     SetState(eStateStepping);
1789   else
1790     SetState(eStateRunning);
1791
1792   // Now resume our task.
1793   m_task.Resume();
1794 }
1795
1796 DNBBreakpoint *MachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length,
1797                                              bool hardware) {
1798   DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
1799                                     "0x%8.8llx, length = %llu, hardware = %i)",
1800                    (uint64_t)addr, (uint64_t)length, hardware);
1801
1802   DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
1803   if (bp)
1804     bp->Retain();
1805   else
1806     bp = m_breakpoints.Add(addr, length, hardware);
1807
1808   if (EnableBreakpoint(addr)) {
1809     DNBLogThreadedIf(LOG_BREAKPOINTS,
1810                      "MachProcess::CreateBreakpoint ( addr = "
1811                      "0x%8.8llx, length = %llu) => %p",
1812                      (uint64_t)addr, (uint64_t)length, static_cast<void *>(bp));
1813     return bp;
1814   } else if (bp->Release() == 0) {
1815     m_breakpoints.Remove(addr);
1816   }
1817   // We failed to enable the breakpoint
1818   return NULL;
1819 }
1820
1821 DNBBreakpoint *MachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length,
1822                                              uint32_t watch_flags,
1823                                              bool hardware) {
1824   DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
1825                                     "0x%8.8llx, length = %llu, flags = "
1826                                     "0x%8.8x, hardware = %i)",
1827                    (uint64_t)addr, (uint64_t)length, watch_flags, hardware);
1828
1829   DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
1830   // since the Z packets only send an address, we can only have one watchpoint
1831   // at
1832   // an address. If there is already one, we must refuse to create another
1833   // watchpoint
1834   if (wp)
1835     return NULL;
1836
1837   wp = m_watchpoints.Add(addr, length, hardware);
1838   wp->SetIsWatchpoint(watch_flags);
1839
1840   if (EnableWatchpoint(addr)) {
1841     DNBLogThreadedIf(LOG_WATCHPOINTS,
1842                      "MachProcess::CreateWatchpoint ( addr = "
1843                      "0x%8.8llx, length = %llu) => %p",
1844                      (uint64_t)addr, (uint64_t)length, static_cast<void *>(wp));
1845     return wp;
1846   } else {
1847     DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
1848                                       "0x%8.8llx, length = %llu) => FAILED",
1849                      (uint64_t)addr, (uint64_t)length);
1850     m_watchpoints.Remove(addr);
1851   }
1852   // We failed to enable the watchpoint
1853   return NULL;
1854 }
1855
1856 void MachProcess::DisableAllBreakpoints(bool remove) {
1857   DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::%s (remove = %d )",
1858                    __FUNCTION__, remove);
1859
1860   m_breakpoints.DisableAllBreakpoints(this);
1861
1862   if (remove)
1863     m_breakpoints.RemoveDisabled();
1864 }
1865
1866 void MachProcess::DisableAllWatchpoints(bool remove) {
1867   DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::%s (remove = %d )",
1868                    __FUNCTION__, remove);
1869
1870   m_watchpoints.DisableAllWatchpoints(this);
1871
1872   if (remove)
1873     m_watchpoints.RemoveDisabled();
1874 }
1875
1876 bool MachProcess::DisableBreakpoint(nub_addr_t addr, bool remove) {
1877   DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
1878   if (bp) {
1879     // After "exec" we might end up with a bunch of breakpoints that were
1880     // disabled
1881     // manually, just ignore them
1882     if (!bp->IsEnabled()) {
1883       // Breakpoint might have been disabled by an exec
1884       if (remove && bp->Release() == 0) {
1885         m_thread_list.NotifyBreakpointChanged(bp);
1886         m_breakpoints.Remove(addr);
1887       }
1888       return true;
1889     }
1890
1891     // We have multiple references to this breakpoint, decrement the ref count
1892     // and if it isn't zero, then return true;
1893     if (remove && bp->Release() > 0)
1894       return true;
1895
1896     DNBLogThreadedIf(
1897         LOG_BREAKPOINTS | LOG_VERBOSE,
1898         "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = %d )",
1899         (uint64_t)addr, remove);
1900
1901     if (bp->IsHardware()) {
1902       bool hw_disable_result = m_thread_list.DisableHardwareBreakpoint(bp);
1903
1904       if (hw_disable_result) {
1905         bp->SetEnabled(false);
1906         // Let the thread list know that a breakpoint has been modified
1907         if (remove) {
1908           m_thread_list.NotifyBreakpointChanged(bp);
1909           m_breakpoints.Remove(addr);
1910         }
1911         DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::DisableBreakpoint ( "
1912                                           "addr = 0x%8.8llx, remove = %d ) "
1913                                           "(hardware) => success",
1914                          (uint64_t)addr, remove);
1915         return true;
1916       }
1917
1918       return false;
1919     }
1920
1921     const nub_size_t break_op_size = bp->ByteSize();
1922     assert(break_op_size > 0);
1923     const uint8_t *const break_op =
1924         DNBArchProtocol::GetBreakpointOpcode(bp->ByteSize());
1925     if (break_op_size > 0) {
1926       // Clear a software breakpoint instruction
1927       uint8_t curr_break_op[break_op_size];
1928       bool break_op_found = false;
1929
1930       // Read the breakpoint opcode
1931       if (m_task.ReadMemory(addr, break_op_size, curr_break_op) ==
1932           break_op_size) {
1933         bool verify = false;
1934         if (bp->IsEnabled()) {
1935           // Make sure a breakpoint opcode exists at this address
1936           if (memcmp(curr_break_op, break_op, break_op_size) == 0) {
1937             break_op_found = true;
1938             // We found a valid breakpoint opcode at this address, now restore
1939             // the saved opcode.
1940             if (m_task.WriteMemory(addr, break_op_size,
1941                                    bp->SavedOpcodeBytes()) == break_op_size) {
1942               verify = true;
1943             } else {
1944               DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
1945                           "remove = %d ) memory write failed when restoring "
1946                           "original opcode",
1947                           (uint64_t)addr, remove);
1948             }
1949           } else {
1950             DNBLogWarning("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
1951                           "remove = %d ) expected a breakpoint opcode but "
1952                           "didn't find one.",
1953                           (uint64_t)addr, remove);
1954             // Set verify to true and so we can check if the original opcode has
1955             // already been restored
1956             verify = true;
1957           }
1958         } else {
1959           DNBLogThreadedIf(LOG_BREAKPOINTS | LOG_VERBOSE,
1960                            "MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, "
1961                            "remove = %d ) is not enabled",
1962                            (uint64_t)addr, remove);
1963           // Set verify to true and so we can check if the original opcode is
1964           // there
1965           verify = true;
1966         }
1967
1968         if (verify) {
1969           uint8_t verify_opcode[break_op_size];
1970           // Verify that our original opcode made it back to the inferior
1971           if (m_task.ReadMemory(addr, break_op_size, verify_opcode) ==
1972               break_op_size) {
1973             // compare the memory we just read with the original opcode
1974             if (memcmp(bp->SavedOpcodeBytes(), verify_opcode, break_op_size) ==
1975                 0) {
1976               // SUCCESS
1977               bp->SetEnabled(false);
1978               // Let the thread list know that a breakpoint has been modified
1979               if (remove && bp->Release() == 0) {
1980                 m_thread_list.NotifyBreakpointChanged(bp);
1981                 m_breakpoints.Remove(addr);
1982               }
1983               DNBLogThreadedIf(LOG_BREAKPOINTS,
1984                                "MachProcess::DisableBreakpoint ( addr = "
1985                                "0x%8.8llx, remove = %d ) => success",
1986                                (uint64_t)addr, remove);
1987               return true;
1988             } else {
1989               if (break_op_found)
1990                 DNBLogError("MachProcess::DisableBreakpoint ( addr = "
1991                             "0x%8.8llx, remove = %d ) : failed to restore "
1992                             "original opcode",
1993                             (uint64_t)addr, remove);
1994               else
1995                 DNBLogError("MachProcess::DisableBreakpoint ( addr = "
1996                             "0x%8.8llx, remove = %d ) : opcode changed",
1997                             (uint64_t)addr, remove);
1998             }
1999           } else {
2000             DNBLogWarning("MachProcess::DisableBreakpoint: unable to disable "
2001                           "breakpoint 0x%8.8llx",
2002                           (uint64_t)addr);
2003           }
2004         }
2005       } else {
2006         DNBLogWarning("MachProcess::DisableBreakpoint: unable to read memory "
2007                       "at 0x%8.8llx",
2008                       (uint64_t)addr);
2009       }
2010     }
2011   } else {
2012     DNBLogError("MachProcess::DisableBreakpoint ( addr = 0x%8.8llx, remove = "
2013                 "%d ) invalid breakpoint address",
2014                 (uint64_t)addr, remove);
2015   }
2016   return false;
2017 }
2018
2019 bool MachProcess::DisableWatchpoint(nub_addr_t addr, bool remove) {
2020   DNBLogThreadedIf(LOG_WATCHPOINTS,
2021                    "MachProcess::%s(addr = 0x%8.8llx, remove = %d)",
2022                    __FUNCTION__, (uint64_t)addr, remove);
2023   DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
2024   if (wp) {
2025     // If we have multiple references to a watchpoint, removing the watchpoint
2026     // shouldn't clear it
2027     if (remove && wp->Release() > 0)
2028       return true;
2029
2030     nub_addr_t addr = wp->Address();
2031     DNBLogThreadedIf(
2032         LOG_WATCHPOINTS,
2033         "MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = %d )",
2034         (uint64_t)addr, remove);
2035
2036     if (wp->IsHardware()) {
2037       bool hw_disable_result = m_thread_list.DisableHardwareWatchpoint(wp);
2038
2039       if (hw_disable_result) {
2040         wp->SetEnabled(false);
2041         if (remove)
2042           m_watchpoints.Remove(addr);
2043         DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::Disablewatchpoint ( "
2044                                           "addr = 0x%8.8llx, remove = %d ) "
2045                                           "(hardware) => success",
2046                          (uint64_t)addr, remove);
2047         return true;
2048       }
2049     }
2050
2051     // TODO: clear software watchpoints if we implement them
2052   } else {
2053     DNBLogError("MachProcess::DisableWatchpoint ( addr = 0x%8.8llx, remove = "
2054                 "%d ) invalid watchpoint ID",
2055                 (uint64_t)addr, remove);
2056   }
2057   return false;
2058 }
2059
2060 uint32_t MachProcess::GetNumSupportedHardwareWatchpoints() const {
2061   return m_thread_list.NumSupportedHardwareWatchpoints();
2062 }
2063
2064 bool MachProcess::EnableBreakpoint(nub_addr_t addr) {
2065   DNBLogThreadedIf(LOG_BREAKPOINTS,
2066                    "MachProcess::EnableBreakpoint ( addr = 0x%8.8llx )",
2067                    (uint64_t)addr);
2068   DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
2069   if (bp) {
2070     if (bp->IsEnabled()) {
2071       DNBLogWarning("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
2072                     "breakpoint already enabled.",
2073                     (uint64_t)addr);
2074       return true;
2075     } else {
2076       if (bp->HardwarePreferred()) {
2077         bp->SetHardwareIndex(m_thread_list.EnableHardwareBreakpoint(bp));
2078         if (bp->IsHardware()) {
2079           bp->SetEnabled(true);
2080           return true;
2081         }
2082       }
2083
2084       const nub_size_t break_op_size = bp->ByteSize();
2085       assert(break_op_size != 0);
2086       const uint8_t *const break_op =
2087           DNBArchProtocol::GetBreakpointOpcode(break_op_size);
2088       if (break_op_size > 0) {
2089         // Save the original opcode by reading it
2090         if (m_task.ReadMemory(addr, break_op_size, bp->SavedOpcodeBytes()) ==
2091             break_op_size) {
2092           // Write a software breakpoint in place of the original opcode
2093           if (m_task.WriteMemory(addr, break_op_size, break_op) ==
2094               break_op_size) {
2095             uint8_t verify_break_op[4];
2096             if (m_task.ReadMemory(addr, break_op_size, verify_break_op) ==
2097                 break_op_size) {
2098               if (memcmp(break_op, verify_break_op, break_op_size) == 0) {
2099                 bp->SetEnabled(true);
2100                 // Let the thread list know that a breakpoint has been modified
2101                 m_thread_list.NotifyBreakpointChanged(bp);
2102                 DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::"
2103                                                   "EnableBreakpoint ( addr = "
2104                                                   "0x%8.8llx ) : SUCCESS.",
2105                                  (uint64_t)addr);
2106                 return true;
2107               } else {
2108                 DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx "
2109                             "): breakpoint opcode verification failed.",
2110                             (uint64_t)addr);
2111               }
2112             } else {
2113               DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
2114                           "unable to read memory to verify breakpoint opcode.",
2115                           (uint64_t)addr);
2116             }
2117           } else {
2118             DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
2119                         "unable to write breakpoint opcode to memory.",
2120                         (uint64_t)addr);
2121           }
2122         } else {
2123           DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ): "
2124                       "unable to read memory at breakpoint address.",
2125                       (uint64_t)addr);
2126         }
2127       } else {
2128         DNBLogError("MachProcess::EnableBreakpoint ( addr = 0x%8.8llx ) no "
2129                     "software breakpoint opcode for current architecture.",
2130                     (uint64_t)addr);
2131       }
2132     }
2133   }
2134   return false;
2135 }
2136
2137 bool MachProcess::EnableWatchpoint(nub_addr_t addr) {
2138   DNBLogThreadedIf(LOG_WATCHPOINTS,
2139                    "MachProcess::EnableWatchpoint(addr = 0x%8.8llx)",
2140                    (uint64_t)addr);
2141   DNBBreakpoint *wp = m_watchpoints.FindByAddress(addr);
2142   if (wp) {
2143     nub_addr_t addr = wp->Address();
2144     if (wp->IsEnabled()) {
2145       DNBLogWarning("MachProcess::EnableWatchpoint(addr = 0x%8.8llx): "
2146                     "watchpoint already enabled.",
2147                     (uint64_t)addr);
2148       return true;
2149     } else {
2150       // Currently only try and set hardware watchpoints.
2151       wp->SetHardwareIndex(m_thread_list.EnableHardwareWatchpoint(wp));
2152       if (wp->IsHardware()) {
2153         wp->SetEnabled(true);
2154         return true;
2155       }
2156       // TODO: Add software watchpoints by doing page protection tricks.
2157     }
2158   }
2159   return false;
2160 }
2161
2162 // Called by the exception thread when an exception has been received from
2163 // our process. The exception message is completely filled and the exception
2164 // data has already been copied.
2165 void MachProcess::ExceptionMessageReceived(
2166     const MachException::Message &exceptionMessage) {
2167   PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
2168
2169   if (m_exception_messages.empty())
2170     m_task.Suspend();
2171
2172   DNBLogThreadedIf(LOG_EXCEPTIONS, "MachProcess::ExceptionMessageReceived ( )");
2173
2174   // Use a locker to automatically unlock our mutex in case of exceptions
2175   // Add the exception to our internal exception stack
2176   m_exception_messages.push_back(exceptionMessage);
2177 }
2178
2179 task_t MachProcess::ExceptionMessageBundleComplete() {
2180   // We have a complete bundle of exceptions for our child process.
2181   PTHREAD_MUTEX_LOCKER(locker, m_exception_messages_mutex);
2182   DNBLogThreadedIf(LOG_EXCEPTIONS, "%s: %llu exception messages.",
2183                    __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
2184   bool auto_resume = false;
2185   if (!m_exception_messages.empty()) {
2186     m_did_exec = false;
2187     // First check for any SIGTRAP and make sure we didn't exec
2188     const task_t task = m_task.TaskPort();
2189     size_t i;
2190     if (m_pid != 0) {
2191       bool received_interrupt = false;
2192       uint32_t num_task_exceptions = 0;
2193       for (i = 0; i < m_exception_messages.size(); ++i) {
2194         if (m_exception_messages[i].state.task_port == task) {
2195           ++num_task_exceptions;
2196           const int signo = m_exception_messages[i].state.SoftSignal();
2197           if (signo == SIGTRAP) {
2198             // SIGTRAP could mean that we exec'ed. We need to check the
2199             // dyld all_image_infos.infoArray to see if it is NULL and if
2200             // so, say that we exec'ed.
2201             const nub_addr_t aii_addr = GetDYLDAllImageInfosAddress();
2202             if (aii_addr != INVALID_NUB_ADDRESS) {
2203               const nub_addr_t info_array_count_addr = aii_addr + 4;
2204               uint32_t info_array_count = 0;
2205               if (m_task.ReadMemory(info_array_count_addr, 4,
2206                                     &info_array_count) == 4) {
2207                 if (info_array_count == 0) {
2208                   m_did_exec = true;
2209                   // Force the task port to update itself in case the task port
2210                   // changed after exec
2211                   DNBError err;
2212                   const task_t old_task = m_task.TaskPort();
2213                   const task_t new_task =
2214                       m_task.TaskPortForProcessID(err, true);
2215                   if (old_task != new_task)
2216                     DNBLogThreadedIf(
2217                         LOG_PROCESS,
2218                         "exec: task changed from 0x%4.4x to 0x%4.4x", old_task,
2219                         new_task);
2220                 }
2221               } else {
2222                 DNBLog("error: failed to read all_image_infos.infoArrayCount "
2223                        "from 0x%8.8llx",
2224                        (uint64_t)info_array_count_addr);
2225               }
2226             }
2227             break;
2228           } else if (m_sent_interrupt_signo != 0 &&
2229                      signo == m_sent_interrupt_signo) {
2230             received_interrupt = true;
2231           }
2232         }
2233       }
2234
2235       if (m_did_exec) {
2236         cpu_type_t process_cpu_type =
2237             MachProcess::GetCPUTypeForLocalProcess(m_pid);
2238         if (m_cpu_type != process_cpu_type) {
2239           DNBLog("arch changed from 0x%8.8x to 0x%8.8x", m_cpu_type,
2240                  process_cpu_type);
2241           m_cpu_type = process_cpu_type;
2242           DNBArchProtocol::SetArchitecture(process_cpu_type);
2243         }
2244         m_thread_list.Clear();
2245         m_activities.Clear();
2246         m_breakpoints.DisableAll();
2247       }
2248
2249       if (m_sent_interrupt_signo != 0) {
2250         if (received_interrupt) {
2251           DNBLogThreadedIf(LOG_PROCESS,
2252                            "MachProcess::ExceptionMessageBundleComplete(): "
2253                            "process successfully interrupted with signal %i",
2254                            m_sent_interrupt_signo);
2255
2256           // Mark that we received the interrupt signal
2257           m_sent_interrupt_signo = 0;
2258           // Not check if we had a case where:
2259           // 1 - We called MachProcess::Interrupt() but we stopped for another
2260           // reason
2261           // 2 - We called MachProcess::Resume() (but still haven't gotten the
2262           // interrupt signal)
2263           // 3 - We are now incorrectly stopped because we are handling the
2264           // interrupt signal we missed
2265           // 4 - We might need to resume if we stopped only with the interrupt
2266           // signal that we never handled
2267           if (m_auto_resume_signo != 0) {
2268             // Only auto_resume if we stopped with _only_ the interrupt signal
2269             if (num_task_exceptions == 1) {
2270               auto_resume = true;
2271               DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
2272                                             "ExceptionMessageBundleComplete(): "
2273                                             "auto resuming due to unhandled "
2274                                             "interrupt signal %i",
2275                                m_auto_resume_signo);
2276             }
2277             m_auto_resume_signo = 0;
2278           }
2279         } else {
2280           DNBLogThreadedIf(LOG_PROCESS, "MachProcess::"
2281                                         "ExceptionMessageBundleComplete(): "
2282                                         "didn't get signal %i after "
2283                                         "MachProcess::Interrupt()",
2284                            m_sent_interrupt_signo);
2285         }
2286       }
2287     }
2288
2289     // Let all threads recover from stopping and do any clean up based
2290     // on the previous thread state (if any).
2291     m_thread_list.ProcessDidStop(this);
2292     m_activities.Clear();
2293
2294     // Let each thread know of any exceptions
2295     for (i = 0; i < m_exception_messages.size(); ++i) {
2296       // Let the thread list figure use the MachProcess to forward all
2297       // exceptions
2298       // on down to each thread.
2299       if (m_exception_messages[i].state.task_port == task)
2300         m_thread_list.NotifyException(m_exception_messages[i].state);
2301       if (DNBLogCheckLogBit(LOG_EXCEPTIONS))
2302         m_exception_messages[i].Dump();
2303     }
2304
2305     if (DNBLogCheckLogBit(LOG_THREAD))
2306       m_thread_list.Dump();
2307
2308     bool step_more = false;
2309     if (m_thread_list.ShouldStop(step_more) && !auto_resume) {
2310       // Wait for the eEventProcessRunningStateChanged event to be reset
2311       // before changing state to stopped to avoid race condition with
2312       // very fast start/stops
2313       struct timespec timeout;
2314       // DNBTimer::OffsetTimeOfDay(&timeout, 0, 250 * 1000);   // Wait for 250
2315       // ms
2316       DNBTimer::OffsetTimeOfDay(&timeout, 1, 0); // Wait for 250 ms
2317       m_events.WaitForEventsToReset(eEventProcessRunningStateChanged, &timeout);
2318       SetState(eStateStopped);
2319     } else {
2320       // Resume without checking our current state.
2321       PrivateResume();
2322     }
2323   } else {
2324     DNBLogThreadedIf(
2325         LOG_EXCEPTIONS, "%s empty exception messages bundle (%llu exceptions).",
2326         __PRETTY_FUNCTION__, (uint64_t)m_exception_messages.size());
2327   }
2328   return m_task.TaskPort();
2329 }
2330
2331 nub_size_t
2332 MachProcess::CopyImageInfos(struct DNBExecutableImageInfo **image_infos,
2333                             bool only_changed) {
2334   if (m_image_infos_callback != NULL)
2335     return m_image_infos_callback(ProcessID(), image_infos, only_changed,
2336                                   m_image_infos_baton);
2337   return 0;
2338 }
2339
2340 void MachProcess::SharedLibrariesUpdated() {
2341   uint32_t event_bits = eEventSharedLibsStateChange;
2342   // Set the shared library event bit to let clients know of shared library
2343   // changes
2344   m_events.SetEvents(event_bits);
2345   // Wait for the event bit to reset if a reset ACK is requested
2346   m_events.WaitForResetAck(event_bits);
2347 }
2348
2349 void MachProcess::SetExitInfo(const char *info) {
2350   if (info && info[0]) {
2351     DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(\"%s\")", __FUNCTION__,
2352                      info);
2353     m_exit_info.assign(info);
2354   } else {
2355     DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s(NULL)", __FUNCTION__);
2356     m_exit_info.clear();
2357   }
2358 }
2359
2360 void MachProcess::AppendSTDOUT(char *s, size_t len) {
2361   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (<%llu> %s) ...", __FUNCTION__,
2362                    (uint64_t)len, s);
2363   PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
2364   m_stdout_data.append(s, len);
2365   m_events.SetEvents(eEventStdioAvailable);
2366
2367   // Wait for the event bit to reset if a reset ACK is requested
2368   m_events.WaitForResetAck(eEventStdioAvailable);
2369 }
2370
2371 size_t MachProcess::GetAvailableSTDOUT(char *buf, size_t buf_size) {
2372   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
2373                    static_cast<void *>(buf), (uint64_t)buf_size);
2374   PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
2375   size_t bytes_available = m_stdout_data.size();
2376   if (bytes_available > 0) {
2377     if (bytes_available > buf_size) {
2378       memcpy(buf, m_stdout_data.data(), buf_size);
2379       m_stdout_data.erase(0, buf_size);
2380       bytes_available = buf_size;
2381     } else {
2382       memcpy(buf, m_stdout_data.data(), bytes_available);
2383       m_stdout_data.clear();
2384     }
2385   }
2386   return bytes_available;
2387 }
2388
2389 nub_addr_t MachProcess::GetDYLDAllImageInfosAddress() {
2390   DNBError err;
2391   return m_task.GetDYLDAllImageInfosAddress(err);
2392 }
2393
2394 size_t MachProcess::GetAvailableSTDERR(char *buf, size_t buf_size) { return 0; }
2395
2396 void *MachProcess::STDIOThread(void *arg) {
2397   MachProcess *proc = (MachProcess *)arg;
2398   DNBLogThreadedIf(LOG_PROCESS,
2399                    "MachProcess::%s ( arg = %p ) thread starting...",
2400                    __FUNCTION__, arg);
2401
2402 #if defined(__APPLE__)
2403   pthread_setname_np("stdio monitoring thread");
2404 #endif
2405
2406   // We start use a base and more options so we can control if we
2407   // are currently using a timeout on the mach_msg. We do this to get a
2408   // bunch of related exceptions on our exception port so we can process
2409   // then together. When we have multiple threads, we can get an exception
2410   // per thread and they will come in consecutively. The main thread loop
2411   // will start by calling mach_msg to without having the MACH_RCV_TIMEOUT
2412   // flag set in the options, so we will wait forever for an exception on
2413   // our exception port. After we get one exception, we then will use the
2414   // MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
2415   // exceptions for our process. After we have received the last pending
2416   // exception, we will get a timeout which enables us to then notify
2417   // our main thread that we have an exception bundle available. We then wait
2418   // for the main thread to tell this exception thread to start trying to get
2419   // exceptions messages again and we start again with a mach_msg read with
2420   // infinite timeout.
2421   DNBError err;
2422   int stdout_fd = proc->GetStdoutFileDescriptor();
2423   int stderr_fd = proc->GetStderrFileDescriptor();
2424   if (stdout_fd == stderr_fd)
2425     stderr_fd = -1;
2426
2427   while (stdout_fd >= 0 || stderr_fd >= 0) {
2428     ::pthread_testcancel();
2429
2430     fd_set read_fds;
2431     FD_ZERO(&read_fds);
2432     if (stdout_fd >= 0)
2433       FD_SET(stdout_fd, &read_fds);
2434     if (stderr_fd >= 0)
2435       FD_SET(stderr_fd, &read_fds);
2436     int nfds = std::max<int>(stdout_fd, stderr_fd) + 1;
2437
2438     int num_set_fds = select(nfds, &read_fds, NULL, NULL, NULL);
2439     DNBLogThreadedIf(LOG_PROCESS,
2440                      "select (nfds, &read_fds, NULL, NULL, NULL) => %d",
2441                      num_set_fds);
2442
2443     if (num_set_fds < 0) {
2444       int select_errno = errno;
2445       if (DNBLogCheckLogBit(LOG_PROCESS)) {
2446         err.SetError(select_errno, DNBError::POSIX);
2447         err.LogThreadedIfError(
2448             "select (nfds, &read_fds, NULL, NULL, NULL) => %d", num_set_fds);
2449       }
2450
2451       switch (select_errno) {
2452       case EAGAIN: // The kernel was (perhaps temporarily) unable to allocate
2453                    // the requested number of file descriptors, or we have
2454                    // non-blocking IO
2455         break;
2456       case EBADF: // One of the descriptor sets specified an invalid descriptor.
2457         return NULL;
2458         break;
2459       case EINTR:  // A signal was delivered before the time limit expired and
2460                    // before any of the selected events occurred.
2461       case EINVAL: // The specified time limit is invalid. One of its components
2462                    // is negative or too large.
2463       default:     // Other unknown error
2464         break;
2465       }
2466     } else if (num_set_fds == 0) {
2467     } else {
2468       char s[1024];
2469       s[sizeof(s) - 1] = '\0'; // Ensure we have NULL termination
2470       ssize_t bytes_read = 0;
2471       if (stdout_fd >= 0 && FD_ISSET(stdout_fd, &read_fds)) {
2472         do {
2473           bytes_read = ::read(stdout_fd, s, sizeof(s) - 1);
2474           if (bytes_read < 0) {
2475             int read_errno = errno;
2476             DNBLogThreadedIf(LOG_PROCESS,
2477                              "read (stdout_fd, ) => %zd   errno: %d (%s)",
2478                              bytes_read, read_errno, strerror(read_errno));
2479           } else if (bytes_read == 0) {
2480             // EOF...
2481             DNBLogThreadedIf(
2482                 LOG_PROCESS,
2483                 "read (stdout_fd, ) => %zd  (reached EOF for child STDOUT)",
2484                 bytes_read);
2485             stdout_fd = -1;
2486           } else if (bytes_read > 0) {
2487             proc->AppendSTDOUT(s, bytes_read);
2488           }
2489
2490         } while (bytes_read > 0);
2491       }
2492
2493       if (stderr_fd >= 0 && FD_ISSET(stderr_fd, &read_fds)) {
2494         do {
2495           bytes_read = ::read(stderr_fd, s, sizeof(s) - 1);
2496           if (bytes_read < 0) {
2497             int read_errno = errno;
2498             DNBLogThreadedIf(LOG_PROCESS,
2499                              "read (stderr_fd, ) => %zd   errno: %d (%s)",
2500                              bytes_read, read_errno, strerror(read_errno));
2501           } else if (bytes_read == 0) {
2502             // EOF...
2503             DNBLogThreadedIf(
2504                 LOG_PROCESS,
2505                 "read (stderr_fd, ) => %zd  (reached EOF for child STDERR)",
2506                 bytes_read);
2507             stderr_fd = -1;
2508           } else if (bytes_read > 0) {
2509             proc->AppendSTDOUT(s, bytes_read);
2510           }
2511
2512         } while (bytes_read > 0);
2513       }
2514     }
2515   }
2516   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%p): thread exiting...",
2517                    __FUNCTION__, arg);
2518   return NULL;
2519 }
2520
2521 void MachProcess::SignalAsyncProfileData(const char *info) {
2522   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (%s) ...", __FUNCTION__, info);
2523   PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
2524   m_profile_data.push_back(info);
2525   m_events.SetEvents(eEventProfileDataAvailable);
2526
2527   // Wait for the event bit to reset if a reset ACK is requested
2528   m_events.WaitForResetAck(eEventProfileDataAvailable);
2529 }
2530
2531 size_t MachProcess::GetAsyncProfileData(char *buf, size_t buf_size) {
2532   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
2533                    static_cast<void *>(buf), (uint64_t)buf_size);
2534   PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
2535   if (m_profile_data.empty())
2536     return 0;
2537
2538   size_t bytes_available = m_profile_data.front().size();
2539   if (bytes_available > 0) {
2540     if (bytes_available > buf_size) {
2541       memcpy(buf, m_profile_data.front().data(), buf_size);
2542       m_profile_data.front().erase(0, buf_size);
2543       bytes_available = buf_size;
2544     } else {
2545       memcpy(buf, m_profile_data.front().data(), bytes_available);
2546       m_profile_data.erase(m_profile_data.begin());
2547     }
2548   }
2549   return bytes_available;
2550 }
2551
2552 void *MachProcess::ProfileThread(void *arg) {
2553   MachProcess *proc = (MachProcess *)arg;
2554   DNBLogThreadedIf(LOG_PROCESS,
2555                    "MachProcess::%s ( arg = %p ) thread starting...",
2556                    __FUNCTION__, arg);
2557
2558 #if defined(__APPLE__)
2559   pthread_setname_np("performance profiling thread");
2560 #endif
2561
2562   while (proc->IsProfilingEnabled()) {
2563     nub_state_t state = proc->GetState();
2564     if (state == eStateRunning) {
2565       std::string data =
2566           proc->Task().GetProfileData(proc->GetProfileScanType());
2567       if (!data.empty()) {
2568         proc->SignalAsyncProfileData(data.c_str());
2569       }
2570     } else if ((state == eStateUnloaded) || (state == eStateDetached) ||
2571                (state == eStateUnloaded)) {
2572       // Done. Get out of this thread.
2573       break;
2574     }
2575     timespec ts;
2576     {
2577       using namespace std::chrono;
2578       std::chrono::microseconds dur(proc->ProfileInterval());
2579       const auto dur_secs = duration_cast<seconds>(dur);
2580       const auto dur_usecs = dur % std::chrono::seconds(1);
2581       DNBTimer::OffsetTimeOfDay(&ts, dur_secs.count(),
2582                                 dur_usecs.count());
2583     }
2584     uint32_t bits_set =
2585         proc->m_profile_events.WaitForSetEvents(eMachProcessProfileCancel, &ts);
2586     // If we got bits back, we were told to exit.  Do so.
2587     if (bits_set & eMachProcessProfileCancel)
2588       break;
2589   }
2590   return NULL;
2591 }
2592
2593 pid_t MachProcess::AttachForDebug(pid_t pid, bool unmask_signals, char *err_str,
2594                                   size_t err_len) {
2595   // Clear out and clean up from any current state
2596   Clear();
2597   if (pid != 0) {
2598     DNBError err;
2599     // Make sure the process exists...
2600     if (::getpgid(pid) < 0) {
2601       err.SetErrorToErrno();
2602       const char *err_cstr = err.AsString();
2603       ::snprintf(err_str, err_len, "%s",
2604                  err_cstr ? err_cstr : "No such process");
2605       DNBLogError ("MachProcess::AttachForDebug pid %d does not exist", pid);
2606       return INVALID_NUB_PROCESS;
2607     }
2608
2609     SetState(eStateAttaching);
2610     m_pid = pid;
2611     if (!m_task.StartExceptionThread(unmask_signals, err)) {
2612       const char *err_cstr = err.AsString();
2613       ::snprintf(err_str, err_len, "%s",
2614                  err_cstr ? err_cstr : "unable to start the exception thread");
2615       DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", pid);
2616       DNBLogError(
2617           "[LaunchAttach] END (%d) MachProcess::AttachForDebug failed to start "
2618           "exception thread attaching to pid %i: %s",
2619           getpid(), pid, err_str);
2620       m_pid = INVALID_NUB_PROCESS;
2621       return INVALID_NUB_PROCESS;
2622     }
2623
2624     DNBLog("[LaunchAttach] (%d) About to ptrace(PT_ATTACHEXC, %d)...", getpid(),
2625            pid);
2626     errno = 0;
2627     int ptrace_result = ::ptrace(PT_ATTACHEXC, pid, 0, 0);
2628     int ptrace_errno = errno;
2629     DNBLog("[LaunchAttach] (%d) Completed ptrace(PT_ATTACHEXC, %d) == %d",
2630            getpid(), pid, ptrace_result);
2631     if (ptrace_result != 0) {
2632       err.SetError(ptrace_errno);
2633       DNBLogError("MachProcess::AttachForDebug failed to ptrace(PT_ATTACHEXC) "
2634                   "pid %i: %s",
2635                   pid, err.AsString());
2636     } else {
2637       err.Clear();
2638     }
2639
2640     if (err.Success()) {
2641       m_flags |= eMachProcessFlagsAttached;
2642       // Sleep a bit to let the exception get received and set our process
2643       // status
2644       // to stopped.
2645       ::usleep(250000);
2646       DNBLog("[LaunchAttach] (%d) Done napping after ptrace(PT_ATTACHEXC)'ing",
2647              getpid());
2648       DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", pid);
2649       return m_pid;
2650     } else {
2651       ::snprintf(err_str, err_len, "%s", err.AsString());
2652       DNBLogError(
2653           "[LaunchAttach] (%d) MachProcess::AttachForDebug error: failed to "
2654           "attach to pid %d",
2655           getpid(), pid);
2656
2657       struct kinfo_proc kinfo;
2658       int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
2659       size_t len = sizeof(struct kinfo_proc);
2660       if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), &kinfo, &len, NULL, 0) == 0 && len > 0) {
2661         if (kinfo.kp_proc.p_flag & P_TRACED) {
2662           ::snprintf(err_str, err_len, "%s - process %d is already being debugged", err.AsString(), pid);
2663           DNBLogError(
2664               "[LaunchAttach] (%d) MachProcess::AttachForDebug pid %d is "
2665               "already being debugged",
2666               getpid(), pid);
2667         }
2668       }
2669     }
2670   }
2671   return INVALID_NUB_PROCESS;
2672 }
2673
2674 Genealogy::ThreadActivitySP
2675 MachProcess::GetGenealogyInfoForThread(nub_thread_t tid, bool &timed_out) {
2676   return m_activities.GetGenealogyInfoForThread(m_pid, tid, m_thread_list,
2677                                                 m_task.TaskPort(), timed_out);
2678 }
2679
2680 Genealogy::ProcessExecutableInfoSP
2681 MachProcess::GetGenealogyImageInfo(size_t idx) {
2682   return m_activities.GetProcessExecutableInfosAtIndex(idx);
2683 }
2684
2685 bool MachProcess::GetOSVersionNumbers(uint64_t *major, uint64_t *minor,
2686                                       uint64_t *patch) {
2687   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2688
2689   NSOperatingSystemVersion vers =
2690       [[NSProcessInfo processInfo] operatingSystemVersion];
2691   if (major)
2692     *major = vers.majorVersion;
2693   if (minor)
2694     *minor = vers.minorVersion;
2695   if (patch)
2696     *patch = vers.patchVersion;
2697
2698   [pool drain];
2699
2700   return true;
2701 }
2702
2703 std::string MachProcess::GetMacCatalystVersionString() {
2704   @autoreleasepool {
2705     NSDictionary *version_info =
2706       [NSDictionary dictionaryWithContentsOfFile:
2707        @"/System/Library/CoreServices/SystemVersion.plist"];
2708     NSString *version_value = [version_info objectForKey: @"iOSSupportVersion"];
2709     if (const char *version_str = [version_value UTF8String])
2710       return version_str;
2711   }
2712   return {};
2713 }
2714
2715 #if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
2716 /// Get the app bundle from the given path. Returns the empty string if the
2717 /// path doesn't appear to be an app bundle.
2718 static std::string GetAppBundle(std::string path) {
2719   auto pos = path.rfind(".app");
2720   // Path doesn't contain `.app`.
2721   if (pos == std::string::npos)
2722     return {};
2723   // Path has `.app` extension.
2724   if (pos == path.size() - 4)
2725     return path.substr(0, pos + 4);
2726
2727   // Look for `.app` before a path separator.
2728   do {
2729     if (path[pos + 4] == '/')
2730       return path.substr(0, pos + 4);
2731     path = path.substr(0, pos);
2732     pos = path.rfind(".app");
2733   } while (pos != std::string::npos);
2734
2735   return {};
2736 }
2737 #endif
2738
2739 // Do the process specific setup for attach.  If this returns NULL, then there's
2740 // no
2741 // platform specific stuff to be done to wait for the attach.  If you get
2742 // non-null,
2743 // pass that token to the CheckForProcess method, and then to
2744 // CleanupAfterAttach.
2745
2746 //  Call PrepareForAttach before attaching to a process that has not yet
2747 //  launched
2748 // This returns a token that can be passed to CheckForProcess, and to
2749 // CleanupAfterAttach.
2750 // You should call CleanupAfterAttach to free the token, and do whatever other
2751 // cleanup seems good.
2752
2753 const void *MachProcess::PrepareForAttach(const char *path,
2754                                           nub_launch_flavor_t launch_flavor,
2755                                           bool waitfor, DNBError &attach_err) {
2756 #if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
2757   // Tell SpringBoard to halt the next launch of this application on startup.
2758
2759   if (!waitfor)
2760     return NULL;
2761
2762   std::string app_bundle_path = GetAppBundle(path);
2763   if (app_bundle_path.empty()) {
2764     DNBLogThreadedIf(
2765         LOG_PROCESS,
2766         "MachProcess::PrepareForAttach(): path '%s' doesn't contain .app, "
2767         "we can't tell springboard to wait for launch...",
2768         path);
2769     return NULL;
2770   }
2771
2772 #if defined(WITH_FBS)
2773   if (launch_flavor == eLaunchFlavorDefault)
2774     launch_flavor = eLaunchFlavorFBS;
2775   if (launch_flavor != eLaunchFlavorFBS)
2776     return NULL;
2777 #elif defined(WITH_BKS)
2778   if (launch_flavor == eLaunchFlavorDefault)
2779     launch_flavor = eLaunchFlavorBKS;
2780   if (launch_flavor != eLaunchFlavorBKS)
2781     return NULL;
2782 #elif defined(WITH_SPRINGBOARD)
2783   if (launch_flavor == eLaunchFlavorDefault)
2784     launch_flavor = eLaunchFlavorSpringBoard;
2785   if (launch_flavor != eLaunchFlavorSpringBoard)
2786     return NULL;
2787 #endif
2788
2789   CFStringRef bundleIDCFStr =
2790       CopyBundleIDForPath(app_bundle_path.c_str(), attach_err);
2791   std::string bundleIDStr;
2792   CFString::UTF8(bundleIDCFStr, bundleIDStr);
2793   DNBLogThreadedIf(LOG_PROCESS,
2794                    "CopyBundleIDForPath (%s, err_str) returned @\"%s\"",
2795                    app_bundle_path.c_str(), bundleIDStr.c_str());
2796
2797   if (bundleIDCFStr == NULL) {
2798     return NULL;
2799   }
2800
2801 #if defined(WITH_FBS)
2802   if (launch_flavor == eLaunchFlavorFBS) {
2803     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2804
2805     NSString *stdio_path = nil;
2806     NSFileManager *file_manager = [NSFileManager defaultManager];
2807     const char *null_path = "/dev/null";
2808     stdio_path =
2809         [file_manager stringWithFileSystemRepresentation:null_path
2810                                                   length:strlen(null_path)];
2811
2812     NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
2813     NSMutableDictionary *options = [NSMutableDictionary dictionary];
2814
2815     DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
2816                                   "@\"%s\",options include stdio path: \"%s\", "
2817                                   "BKSDebugOptionKeyDebugOnNextLaunch & "
2818                                   "BKSDebugOptionKeyWaitForDebugger )",
2819                      bundleIDStr.c_str(), null_path);
2820
2821     [debug_options setObject:stdio_path
2822                       forKey:FBSDebugOptionKeyStandardOutPath];
2823     [debug_options setObject:stdio_path
2824                       forKey:FBSDebugOptionKeyStandardErrorPath];
2825     [debug_options setObject:[NSNumber numberWithBool:YES]
2826                       forKey:FBSDebugOptionKeyWaitForDebugger];
2827     [debug_options setObject:[NSNumber numberWithBool:YES]
2828                       forKey:FBSDebugOptionKeyDebugOnNextLaunch];
2829
2830     [options setObject:debug_options
2831                 forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
2832
2833     FBSSystemService *system_service = [[FBSSystemService alloc] init];
2834
2835     mach_port_t client_port = [system_service createClientPort];
2836     __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
2837     __block FBSOpenApplicationErrorCode attach_error_code =
2838         FBSOpenApplicationErrorCodeNone;
2839
2840     NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
2841
2842     DNBLog("[LaunchAttach] START (%d) requesting FBS launch of app with bundle "
2843            "ID '%s'",
2844            getpid(), bundleIDStr.c_str());
2845     [system_service openApplication:bundleIDNSStr
2846                             options:options
2847                          clientPort:client_port
2848                          withResult:^(NSError *error) {
2849                            // The system service will cleanup the client port we
2850                            // created for us.
2851                            if (error)
2852                              attach_error_code =
2853                                  (FBSOpenApplicationErrorCode)[error code];
2854
2855                            [system_service release];
2856                            dispatch_semaphore_signal(semaphore);
2857                          }];
2858
2859     const uint32_t timeout_secs = 9;
2860
2861     dispatch_time_t timeout =
2862         dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
2863
2864     long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
2865
2866     if (!success) {
2867       DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
2868       attach_err.SetErrorString(
2869           "debugserver timed out waiting for openApplication to complete.");
2870       attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
2871     } else if (attach_error_code != FBSOpenApplicationErrorCodeNone) {
2872       std::string empty_str;
2873       SetFBSError(attach_error_code, empty_str, attach_err);
2874       DNBLogError("unable to launch the application with CFBundleIdentifier "
2875                   "'%s' bks_error = %ld",
2876                   bundleIDStr.c_str(), (NSInteger)attach_error_code);
2877     }
2878     dispatch_release(semaphore);
2879     [pool drain];
2880   }
2881 #endif
2882 #if defined(WITH_BKS)
2883   if (launch_flavor == eLaunchFlavorBKS) {
2884     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2885
2886     NSString *stdio_path = nil;
2887     NSFileManager *file_manager = [NSFileManager defaultManager];
2888     const char *null_path = "/dev/null";
2889     stdio_path =
2890         [file_manager stringWithFileSystemRepresentation:null_path
2891                                                   length:strlen(null_path)];
2892
2893     NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
2894     NSMutableDictionary *options = [NSMutableDictionary dictionary];
2895
2896     DNBLogThreadedIf(LOG_PROCESS, "Calling BKSSystemService openApplication: "
2897                                   "@\"%s\",options include stdio path: \"%s\", "
2898                                   "BKSDebugOptionKeyDebugOnNextLaunch & "
2899                                   "BKSDebugOptionKeyWaitForDebugger )",
2900                      bundleIDStr.c_str(), null_path);
2901
2902     [debug_options setObject:stdio_path
2903                       forKey:BKSDebugOptionKeyStandardOutPath];
2904     [debug_options setObject:stdio_path
2905                       forKey:BKSDebugOptionKeyStandardErrorPath];
2906     [debug_options setObject:[NSNumber numberWithBool:YES]
2907                       forKey:BKSDebugOptionKeyWaitForDebugger];
2908     [debug_options setObject:[NSNumber numberWithBool:YES]
2909                       forKey:BKSDebugOptionKeyDebugOnNextLaunch];
2910
2911     [options setObject:debug_options
2912                 forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
2913
2914     BKSSystemService *system_service = [[BKSSystemService alloc] init];
2915
2916     mach_port_t client_port = [system_service createClientPort];
2917     __block dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
2918     __block BKSOpenApplicationErrorCode attach_error_code =
2919         BKSOpenApplicationErrorCodeNone;
2920
2921     NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
2922
2923     DNBLog("[LaunchAttach] START (%d) requesting BKS launch of app with bundle "
2924            "ID '%s'",
2925            getpid(), bundleIDStr.c_str());
2926     [system_service openApplication:bundleIDNSStr
2927                             options:options
2928                          clientPort:client_port
2929                          withResult:^(NSError *error) {
2930                            // The system service will cleanup the client port we
2931                            // created for us.
2932                            if (error)
2933                              attach_error_code =
2934                                  (BKSOpenApplicationErrorCode)[error code];
2935
2936                            [system_service release];
2937                            dispatch_semaphore_signal(semaphore);
2938                          }];
2939
2940     const uint32_t timeout_secs = 9;
2941
2942     dispatch_time_t timeout =
2943         dispatch_time(DISPATCH_TIME_NOW, timeout_secs * NSEC_PER_SEC);
2944
2945     long success = dispatch_semaphore_wait(semaphore, timeout) == 0;
2946
2947     if (!success) {
2948       DNBLogError("timed out trying to launch %s.", bundleIDStr.c_str());
2949       attach_err.SetErrorString(
2950           "debugserver timed out waiting for openApplication to complete.");
2951       attach_err.SetError(OPEN_APPLICATION_TIMEOUT_ERROR, DNBError::Generic);
2952     } else if (attach_error_code != BKSOpenApplicationErrorCodeNone) {
2953       std::string empty_str;
2954       SetBKSError(attach_error_code, empty_str, attach_err);
2955       DNBLogError("unable to launch the application with CFBundleIdentifier "
2956                   "'%s' bks_error = %d",
2957                   bundleIDStr.c_str(), attach_error_code);
2958     }
2959     dispatch_release(semaphore);
2960     [pool drain];
2961   }
2962 #endif
2963
2964 #if defined(WITH_SPRINGBOARD)
2965   if (launch_flavor == eLaunchFlavorSpringBoard) {
2966     SBSApplicationLaunchError sbs_error = 0;
2967
2968     const char *stdout_err = "/dev/null";
2969     CFString stdio_path;
2970     stdio_path.SetFileSystemRepresentation(stdout_err);
2971
2972     DNBLogThreadedIf(LOG_PROCESS, "SBSLaunchApplicationForDebugging ( @\"%s\" "
2973                                   ", NULL, NULL, NULL, @\"%s\", @\"%s\", "
2974                                   "SBSApplicationDebugOnNextLaunch | "
2975                                   "SBSApplicationLaunchWaitForDebugger )",
2976                      bundleIDStr.c_str(), stdout_err, stdout_err);
2977
2978     DNBLog("[LaunchAttach] START (%d) requesting SpringBoard launch of app "
2979            "with bundle "
2980            "ID '%s'",
2981            getpid(), bundleIDStr.c_str());
2982     sbs_error = SBSLaunchApplicationForDebugging(
2983         bundleIDCFStr,
2984         (CFURLRef)NULL, // openURL
2985         NULL,           // launch_argv.get(),
2986         NULL,           // launch_envp.get(),  // CFDictionaryRef environment
2987         stdio_path.get(), stdio_path.get(),
2988         SBSApplicationDebugOnNextLaunch | SBSApplicationLaunchWaitForDebugger);
2989
2990     if (sbs_error != SBSApplicationLaunchErrorSuccess) {
2991       attach_err.SetError(sbs_error, DNBError::SpringBoard);
2992       return NULL;
2993     }
2994   }
2995 #endif // WITH_SPRINGBOARD
2996
2997   DNBLogThreadedIf(LOG_PROCESS, "Successfully set DebugOnNextLaunch.");
2998   return bundleIDCFStr;
2999 #else // !(defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
3000       // (WITH_FBS))
3001   return NULL;
3002 #endif
3003 }
3004
3005 // Pass in the token you got from PrepareForAttach.  If there is a process
3006 // for that token, then the pid will be returned, otherwise INVALID_NUB_PROCESS
3007 // will be returned.
3008
3009 nub_process_t MachProcess::CheckForProcess(const void *attach_token,
3010                                            nub_launch_flavor_t launch_flavor) {
3011   if (attach_token == NULL)
3012     return INVALID_NUB_PROCESS;
3013
3014 #if defined(WITH_FBS)
3015   if (launch_flavor == eLaunchFlavorFBS) {
3016     NSString *bundleIDNSStr = (NSString *)attach_token;
3017     FBSSystemService *systemService = [[FBSSystemService alloc] init];
3018     pid_t pid = [systemService pidForApplication:bundleIDNSStr];
3019     [systemService release];
3020     if (pid == 0)
3021       return INVALID_NUB_PROCESS;
3022     else
3023       return pid;
3024   }
3025 #endif
3026
3027 #if defined(WITH_BKS)
3028   if (launch_flavor == eLaunchFlavorBKS) {
3029     NSString *bundleIDNSStr = (NSString *)attach_token;
3030     BKSSystemService *systemService = [[BKSSystemService alloc] init];
3031     pid_t pid = [systemService pidForApplication:bundleIDNSStr];
3032     [systemService release];
3033     if (pid == 0)
3034       return INVALID_NUB_PROCESS;
3035     else
3036       return pid;
3037   }
3038 #endif
3039
3040 #if defined(WITH_SPRINGBOARD)
3041   if (launch_flavor == eLaunchFlavorSpringBoard) {
3042     CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
3043     Boolean got_it;
3044     nub_process_t attach_pid;
3045     got_it = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &attach_pid);
3046     if (got_it)
3047       return attach_pid;
3048     else
3049       return INVALID_NUB_PROCESS;
3050   }
3051 #endif
3052   return INVALID_NUB_PROCESS;
3053 }
3054
3055 // Call this to clean up after you have either attached or given up on the
3056 // attach.
3057 // Pass true for success if you have attached, false if you have not.
3058 // The token will also be freed at this point, so you can't use it after calling
3059 // this method.
3060
3061 void MachProcess::CleanupAfterAttach(const void *attach_token,
3062                                      nub_launch_flavor_t launch_flavor,
3063                                      bool success, DNBError &err_str) {
3064   if (attach_token == NULL)
3065     return;
3066
3067 #if defined(WITH_FBS)
3068   if (launch_flavor == eLaunchFlavorFBS) {
3069     if (!success) {
3070       FBSCleanupAfterAttach(attach_token, err_str);
3071     }
3072     CFRelease((CFStringRef)attach_token);
3073   }
3074 #endif
3075
3076 #if defined(WITH_BKS)
3077
3078   if (launch_flavor == eLaunchFlavorBKS) {
3079     if (!success) {
3080       BKSCleanupAfterAttach(attach_token, err_str);
3081     }
3082     CFRelease((CFStringRef)attach_token);
3083   }
3084 #endif
3085
3086 #if defined(WITH_SPRINGBOARD)
3087   // Tell SpringBoard to cancel the debug on next launch of this application
3088   // if we failed to attach
3089   if (launch_flavor == eMachProcessFlagsUsingSpringBoard) {
3090     if (!success) {
3091       SBSApplicationLaunchError sbs_error = 0;
3092       CFStringRef bundleIDCFStr = (CFStringRef)attach_token;
3093
3094       sbs_error = SBSLaunchApplicationForDebugging(
3095           bundleIDCFStr, (CFURLRef)NULL, NULL, NULL, NULL, NULL,
3096           SBSApplicationCancelDebugOnNextLaunch);
3097
3098       if (sbs_error != SBSApplicationLaunchErrorSuccess) {
3099         err_str.SetError(sbs_error, DNBError::SpringBoard);
3100         return;
3101       }
3102     }
3103
3104     CFRelease((CFStringRef)attach_token);
3105   }
3106 #endif
3107 }
3108
3109 pid_t MachProcess::LaunchForDebug(
3110     const char *path, char const *argv[], char const *envp[],
3111     const char *working_directory, // NULL => don't change, non-NULL => set
3112                                    // working directory for inferior to this
3113     const char *stdin_path, const char *stdout_path, const char *stderr_path,
3114     bool no_stdio, nub_launch_flavor_t launch_flavor, int disable_aslr,
3115     const char *event_data, bool unmask_signals, DNBError &launch_err) {
3116   // Clear out and clean up from any current state
3117   Clear();
3118
3119   DNBLogThreadedIf(LOG_PROCESS,
3120                    "%s( path = '%s', argv = %p, envp = %p, "
3121                    "launch_flavor = %u, disable_aslr = %d )",
3122                    __FUNCTION__, path, static_cast<const void *>(argv),
3123                    static_cast<const void *>(envp), launch_flavor,
3124                    disable_aslr);
3125
3126   // Fork a child process for debugging
3127   SetState(eStateLaunching);
3128
3129   switch (launch_flavor) {
3130   case eLaunchFlavorForkExec:
3131     m_pid = MachProcess::ForkChildForPTraceDebugging(path, argv, envp, this,
3132                                                      launch_err);
3133     break;
3134 #ifdef WITH_FBS
3135   case eLaunchFlavorFBS: {
3136     std::string app_bundle_path = GetAppBundle(path);
3137     if (!app_bundle_path.empty()) {
3138       m_flags |= (eMachProcessFlagsUsingFBS | eMachProcessFlagsBoardCalculated);
3139       if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
3140                                      no_stdio, disable_aslr, event_data,
3141                                      unmask_signals, launch_err) != 0)
3142         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
3143                       // non-zero m_pid.
3144     }
3145     DNBLog("Failed to launch '%s' with FBS", app_bundle_path);
3146   } break;
3147 #endif
3148 #ifdef WITH_BKS
3149   case eLaunchFlavorBKS: {
3150     std::string app_bundle_path = GetAppBundle(path);
3151     if (!app_bundle_path.empty()) {
3152       m_flags |= (eMachProcessFlagsUsingBKS | eMachProcessFlagsBoardCalculated);
3153       if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp,
3154                                      no_stdio, disable_aslr, event_data,
3155                                      unmask_signals, launch_err) != 0)
3156         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
3157                       // non-zero m_pid.
3158     }
3159     DNBLog("Failed to launch '%s' with BKS", app_bundle_path);
3160   } break;
3161 #endif
3162 #ifdef WITH_SPRINGBOARD
3163   case eLaunchFlavorSpringBoard: {
3164     std::string app_bundle_path = GetAppBundle(path);
3165     if (!app_bundle_path.empty()) {
3166       if (SBLaunchForDebug(app_bundle_path.c_str(), argv, envp, no_stdio,
3167                            disable_aslr, unmask_signals, launch_err) != 0)
3168         return m_pid; // A successful SBLaunchForDebug() returns and assigns a
3169                       // non-zero m_pid.
3170     }
3171     DNBLog("Failed to launch '%s' with SpringBoard", app_bundle_path);
3172   } break;
3173
3174 #endif
3175
3176   case eLaunchFlavorPosixSpawn:
3177     m_pid = MachProcess::PosixSpawnChildForPTraceDebugging(
3178         path, DNBArchProtocol::GetCPUType(), DNBArchProtocol::GetCPUSubType(),
3179         argv, envp, working_directory, stdin_path, stdout_path, stderr_path,
3180         no_stdio, this, disable_aslr, launch_err);
3181     break;
3182
3183   default:
3184     DNBLog("Failed to launch: invalid launch flavor: %d", launch_flavor);
3185     launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
3186     return INVALID_NUB_PROCESS;
3187   }
3188
3189   if (m_pid == INVALID_NUB_PROCESS) {
3190     // If we don't have a valid process ID and no one has set the error,
3191     // then return a generic error
3192     if (launch_err.Success())
3193       launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
3194   } else {
3195     m_path = path;
3196     size_t i;
3197     char const *arg;
3198     for (i = 0; (arg = argv[i]) != NULL; i++)
3199       m_args.push_back(arg);
3200
3201     m_task.StartExceptionThread(unmask_signals, launch_err);
3202     if (launch_err.Fail()) {
3203       if (launch_err.AsString() == NULL)
3204         launch_err.SetErrorString("unable to start the exception thread");
3205       DNBLog("Could not get inferior's Mach exception port, sending ptrace "
3206              "PT_KILL and exiting.");
3207       ::ptrace(PT_KILL, m_pid, 0, 0);
3208       m_pid = INVALID_NUB_PROCESS;
3209       return INVALID_NUB_PROCESS;
3210     }
3211
3212     StartSTDIOThread();
3213
3214     if (launch_flavor == eLaunchFlavorPosixSpawn) {
3215
3216       SetState(eStateAttaching);
3217       errno = 0;
3218       DNBLog("[LaunchAttach] (%d) About to ptrace(PT_ATTACHEXC, %d)...",
3219              getpid(), m_pid);
3220       int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
3221       int ptrace_errno = errno;
3222       DNBLog("[LaunchAttach] (%d) Completed ptrace(PT_ATTACHEXC, %d) == %d",
3223              getpid(), m_pid, err);
3224       if (err == 0) {
3225         m_flags |= eMachProcessFlagsAttached;
3226         DNBLogThreadedIf(LOG_PROCESS, "successfully spawned pid %d", m_pid);
3227         launch_err.Clear();
3228       } else {
3229         SetState(eStateExited);
3230         DNBError ptrace_err(ptrace_errno, DNBError::POSIX);
3231         DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to spawned pid "
3232                                       "%d (err = %i, errno = %i (%s))",
3233                          m_pid, err, ptrace_err.Status(),
3234                          ptrace_err.AsString());
3235         launch_err.SetError(NUB_GENERIC_ERROR, DNBError::Generic);
3236       }
3237     } else {
3238       launch_err.Clear();
3239     }
3240   }
3241   return m_pid;
3242 }
3243
3244 pid_t MachProcess::PosixSpawnChildForPTraceDebugging(
3245     const char *path, cpu_type_t cpu_type, cpu_subtype_t cpu_subtype,
3246     char const *argv[], char const *envp[], const char *working_directory,
3247     const char *stdin_path, const char *stdout_path, const char *stderr_path,
3248     bool no_stdio, MachProcess *process, int disable_aslr, DNBError &err) {
3249   posix_spawnattr_t attr;
3250   short flags;
3251   DNBLogThreadedIf(LOG_PROCESS,
3252                    "%s ( path='%s', argv=%p, envp=%p, "
3253                    "working_dir=%s, stdin=%s, stdout=%s "
3254                    "stderr=%s, no-stdio=%i)",
3255                    __FUNCTION__, path, static_cast<const void *>(argv),
3256                    static_cast<const void *>(envp), working_directory,
3257                    stdin_path, stdout_path, stderr_path, no_stdio);
3258
3259   err.SetError(::posix_spawnattr_init(&attr), DNBError::POSIX);
3260   if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3261     err.LogThreaded("::posix_spawnattr_init ( &attr )");
3262   if (err.Fail())
3263     return INVALID_NUB_PROCESS;
3264
3265   flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETSIGDEF |
3266           POSIX_SPAWN_SETSIGMASK;
3267   if (disable_aslr)
3268     flags |= _POSIX_SPAWN_DISABLE_ASLR;
3269
3270   sigset_t no_signals;
3271   sigset_t all_signals;
3272   sigemptyset(&no_signals);
3273   sigfillset(&all_signals);
3274   ::posix_spawnattr_setsigmask(&attr, &no_signals);
3275   ::posix_spawnattr_setsigdefault(&attr, &all_signals);
3276
3277   err.SetError(::posix_spawnattr_setflags(&attr, flags), DNBError::POSIX);
3278   if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3279     err.LogThreaded(
3280         "::posix_spawnattr_setflags ( &attr, POSIX_SPAWN_START_SUSPENDED%s )",
3281         flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR"
3282                                           : "");
3283   if (err.Fail())
3284     return INVALID_NUB_PROCESS;
3285
3286 // Don't do this on SnowLeopard, _sometimes_ the TASK_BASIC_INFO will fail
3287 // and we will fail to continue with our process...
3288
3289 // On SnowLeopard we should set "DYLD_NO_PIE" in the inferior environment....
3290
3291   if (cpu_type != 0) {
3292     size_t ocount = 0;
3293     bool slice_preference_set = false;
3294
3295     if (cpu_subtype != 0) {
3296       typedef int (*posix_spawnattr_setarchpref_np_t)(
3297           posix_spawnattr_t *, size_t, cpu_type_t *, cpu_subtype_t *, size_t *);
3298       posix_spawnattr_setarchpref_np_t posix_spawnattr_setarchpref_np_fn =
3299           (posix_spawnattr_setarchpref_np_t)dlsym(
3300               RTLD_DEFAULT, "posix_spawnattr_setarchpref_np");
3301       if (posix_spawnattr_setarchpref_np_fn) {
3302         err.SetError((*posix_spawnattr_setarchpref_np_fn)(
3303             &attr, 1, &cpu_type, &cpu_subtype, &ocount));
3304         slice_preference_set = err.Success();
3305         if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3306           err.LogThreaded(
3307               "::posix_spawnattr_setarchpref_np ( &attr, 1, cpu_type = "
3308               "0x%8.8x, cpu_subtype = 0x%8.8x, count => %llu )",
3309               cpu_type, cpu_subtype, (uint64_t)ocount);
3310         if (err.Fail() != 0 || ocount != 1)
3311           return INVALID_NUB_PROCESS;
3312       }
3313     }
3314
3315     if (!slice_preference_set) {
3316       err.SetError(
3317           ::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount),
3318           DNBError::POSIX);
3319       if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3320         err.LogThreaded(
3321             "::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = "
3322             "0x%8.8x, count => %llu )",
3323             cpu_type, (uint64_t)ocount);
3324
3325       if (err.Fail() != 0 || ocount != 1)
3326         return INVALID_NUB_PROCESS;
3327     }
3328   }
3329
3330   PseudoTerminal pty;
3331
3332   posix_spawn_file_actions_t file_actions;
3333   err.SetError(::posix_spawn_file_actions_init(&file_actions), DNBError::POSIX);
3334   int file_actions_valid = err.Success();
3335   if (!file_actions_valid || DNBLogCheckLogBit(LOG_PROCESS))
3336     err.LogThreaded("::posix_spawn_file_actions_init ( &file_actions )");
3337   int pty_error = -1;
3338   pid_t pid = INVALID_NUB_PROCESS;
3339   if (file_actions_valid) {
3340     if (stdin_path == NULL && stdout_path == NULL && stderr_path == NULL &&
3341         !no_stdio) {
3342       pty_error = pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY);
3343       if (pty_error == PseudoTerminal::success) {
3344         stdin_path = stdout_path = stderr_path = pty.SecondaryName();
3345       }
3346     }
3347
3348     // if no_stdio or std paths not supplied, then route to "/dev/null".
3349     if (no_stdio || stdin_path == NULL || stdin_path[0] == '\0')
3350       stdin_path = "/dev/null";
3351     if (no_stdio || stdout_path == NULL || stdout_path[0] == '\0')
3352       stdout_path = "/dev/null";
3353     if (no_stdio || stderr_path == NULL || stderr_path[0] == '\0')
3354       stderr_path = "/dev/null";
3355
3356     err.SetError(::posix_spawn_file_actions_addopen(&file_actions, STDIN_FILENO,
3357                                                     stdin_path,
3358                                                     O_RDONLY | O_NOCTTY, 0),
3359                  DNBError::POSIX);
3360     if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3361       err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
3362                       "filedes=STDIN_FILENO, path='%s')",
3363                       stdin_path);
3364
3365     err.SetError(::posix_spawn_file_actions_addopen(
3366                      &file_actions, STDOUT_FILENO, stdout_path,
3367                      O_WRONLY | O_NOCTTY | O_CREAT, 0640),
3368                  DNBError::POSIX);
3369     if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3370       err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
3371                       "filedes=STDOUT_FILENO, path='%s')",
3372                       stdout_path);
3373
3374     err.SetError(::posix_spawn_file_actions_addopen(
3375                      &file_actions, STDERR_FILENO, stderr_path,
3376                      O_WRONLY | O_NOCTTY | O_CREAT, 0640),
3377                  DNBError::POSIX);
3378     if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3379       err.LogThreaded("::posix_spawn_file_actions_addopen (&file_actions, "
3380                       "filedes=STDERR_FILENO, path='%s')",
3381                       stderr_path);
3382
3383     // TODO: Verify if we can set the working directory back immediately
3384     // after the posix_spawnp call without creating a race condition???
3385     if (working_directory)
3386       ::chdir(working_directory);
3387
3388     err.SetError(::posix_spawnp(&pid, path, &file_actions, &attr,
3389                                 const_cast<char *const *>(argv),
3390                                 const_cast<char *const *>(envp)),
3391                  DNBError::POSIX);
3392     if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3393       err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
3394                       "%p, attr = %p, argv = %p, envp = %p )",
3395                       pid, path, &file_actions, &attr, argv, envp);
3396   } else {
3397     // TODO: Verify if we can set the working directory back immediately
3398     // after the posix_spawnp call without creating a race condition???
3399     if (working_directory)
3400       ::chdir(working_directory);
3401
3402     err.SetError(::posix_spawnp(&pid, path, NULL, &attr,
3403                                 const_cast<char *const *>(argv),
3404                                 const_cast<char *const *>(envp)),
3405                  DNBError::POSIX);
3406     if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3407       err.LogThreaded("::posix_spawnp ( pid => %i, path = '%s', file_actions = "
3408                       "%p, attr = %p, argv = %p, envp = %p )",
3409                       pid, path, NULL, &attr, argv, envp);
3410   }
3411
3412   // We have seen some cases where posix_spawnp was returning a valid
3413   // looking pid even when an error was returned, so clear it out
3414   if (err.Fail())
3415     pid = INVALID_NUB_PROCESS;
3416
3417   if (pty_error == 0) {
3418     if (process != NULL) {
3419       int primary_fd = pty.ReleasePrimaryFD();
3420       process->SetChildFileDescriptors(primary_fd, primary_fd, primary_fd);
3421     }
3422   }
3423   ::posix_spawnattr_destroy(&attr);
3424
3425   if (pid != INVALID_NUB_PROCESS) {
3426     cpu_type_t pid_cpu_type = MachProcess::GetCPUTypeForLocalProcess(pid);
3427     DNBLogThreadedIf(LOG_PROCESS,
3428                      "MachProcess::%s ( ) pid=%i, cpu_type=0x%8.8x",
3429                      __FUNCTION__, pid, pid_cpu_type);
3430     if (pid_cpu_type)
3431       DNBArchProtocol::SetArchitecture(pid_cpu_type);
3432   }
3433
3434   if (file_actions_valid) {
3435     DNBError err2;
3436     err2.SetError(::posix_spawn_file_actions_destroy(&file_actions),
3437                   DNBError::POSIX);
3438     if (err2.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
3439       err2.LogThreaded("::posix_spawn_file_actions_destroy ( &file_actions )");
3440   }
3441
3442   return pid;
3443 }
3444
3445 uint32_t MachProcess::GetCPUTypeForLocalProcess(pid_t pid) {
3446   int mib[CTL_MAXNAME] = {
3447       0,
3448   };
3449   size_t len = CTL_MAXNAME;
3450   if (::sysctlnametomib("sysctl.proc_cputype", mib, &len))
3451     return 0;
3452
3453   mib[len] = pid;
3454   len++;
3455
3456   cpu_type_t cpu;
3457   size_t cpu_len = sizeof(cpu);
3458   if (::sysctl(mib, static_cast<u_int>(len), &cpu, &cpu_len, 0, 0))
3459     cpu = 0;
3460   return cpu;
3461 }
3462
3463 pid_t MachProcess::ForkChildForPTraceDebugging(const char *path,
3464                                                char const *argv[],
3465                                                char const *envp[],
3466                                                MachProcess *process,
3467                                                DNBError &launch_err) {
3468   PseudoTerminal::Status pty_error = PseudoTerminal::success;
3469
3470   // Use a fork that ties the child process's stdin/out/err to a pseudo
3471   // terminal so we can read it in our MachProcess::STDIOThread
3472   // as unbuffered io.
3473   PseudoTerminal pty;
3474   pid_t pid = pty.Fork(pty_error);
3475
3476   if (pid < 0) {
3477     //--------------------------------------------------------------
3478     // Status during fork.
3479     //--------------------------------------------------------------
3480     return pid;
3481   } else if (pid == 0) {
3482     //--------------------------------------------------------------
3483     // Child process
3484     //--------------------------------------------------------------
3485     ::ptrace(PT_TRACE_ME, 0, 0, 0); // Debug this process
3486     ::ptrace(PT_SIGEXC, 0, 0, 0);   // Get BSD signals as mach exceptions
3487
3488     // If our parent is setgid, lets make sure we don't inherit those
3489     // extra powers due to nepotism.
3490     if (::setgid(getgid()) == 0) {
3491
3492       // Let the child have its own process group. We need to execute
3493       // this call in both the child and parent to avoid a race condition
3494       // between the two processes.
3495       ::setpgid(0, 0); // Set the child process group to match its pid
3496
3497       // Sleep a bit to before the exec call
3498       ::sleep(1);
3499
3500       // Turn this process into
3501       ::execv(path, const_cast<char *const *>(argv));
3502     }
3503     // Exit with error code. Child process should have taken
3504     // over in above exec call and if the exec fails it will
3505     // exit the child process below.
3506     ::exit(127);
3507   } else {
3508     //--------------------------------------------------------------
3509     // Parent process
3510     //--------------------------------------------------------------
3511     // Let the child have its own process group. We need to execute
3512     // this call in both the child and parent to avoid a race condition
3513     // between the two processes.
3514     ::setpgid(pid, pid); // Set the child process group to match its pid
3515
3516     if (process != NULL) {
3517       // Release our primary pty file descriptor so the pty class doesn't
3518       // close it and so we can continue to use it in our STDIO thread
3519       int primary_fd = pty.ReleasePrimaryFD();
3520       process->SetChildFileDescriptors(primary_fd, primary_fd, primary_fd);
3521     }
3522   }
3523   return pid;
3524 }
3525
3526 #if defined(WITH_SPRINGBOARD) || defined(WITH_BKS) || defined(WITH_FBS)
3527 // This returns a CFRetained pointer to the Bundle ID for app_bundle_path,
3528 // or NULL if there was some problem getting the bundle id.
3529 static CFStringRef CopyBundleIDForPath(const char *app_bundle_path,
3530                                        DNBError &err_str) {
3531   CFBundle bundle(app_bundle_path);
3532   CFStringRef bundleIDCFStr = bundle.GetIdentifier();
3533   std::string bundleID;
3534   if (CFString::UTF8(bundleIDCFStr, bundleID) == NULL) {
3535     struct stat app_bundle_stat;
3536     char err_msg[PATH_MAX];
3537
3538     if (::stat(app_bundle_path, &app_bundle_stat) < 0) {
3539       err_str.SetError(errno, DNBError::POSIX);
3540       snprintf(err_msg, sizeof(err_msg), "%s: \"%s\"", err_str.AsString(),
3541                app_bundle_path);
3542       err_str.SetErrorString(err_msg);
3543       DNBLogThreadedIf(LOG_PROCESS, "%s() error: %s", __FUNCTION__, err_msg);
3544     } else {
3545       err_str.SetError(-1, DNBError::Generic);
3546       snprintf(err_msg, sizeof(err_msg),
3547                "failed to extract CFBundleIdentifier from %s", app_bundle_path);
3548       err_str.SetErrorString(err_msg);
3549       DNBLogThreadedIf(
3550           LOG_PROCESS,
3551           "%s() error: failed to extract CFBundleIdentifier from '%s'",
3552           __FUNCTION__, app_bundle_path);
3553     }
3554     return NULL;
3555   }
3556
3557   DNBLogThreadedIf(LOG_PROCESS, "%s() extracted CFBundleIdentifier: %s",
3558                    __FUNCTION__, bundleID.c_str());
3559   CFRetain(bundleIDCFStr);
3560
3561   return bundleIDCFStr;
3562 }
3563 #endif // #if defined (WITH_SPRINGBOARD) || defined (WITH_BKS) || defined
3564        // (WITH_FBS)
3565 #ifdef WITH_SPRINGBOARD
3566
3567 pid_t MachProcess::SBLaunchForDebug(const char *path, char const *argv[],
3568                                     char const *envp[], bool no_stdio,
3569                                     bool disable_aslr, bool unmask_signals,
3570                                     DNBError &launch_err) {
3571   // Clear out and clean up from any current state
3572   Clear();
3573
3574   DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
3575
3576   // Fork a child process for debugging
3577   SetState(eStateLaunching);
3578   m_pid = MachProcess::SBForkChildForPTraceDebugging(path, argv, envp, no_stdio,
3579                                                      this, launch_err);
3580   if (m_pid != 0) {
3581     m_path = path;
3582     size_t i;
3583     char const *arg;
3584     for (i = 0; (arg = argv[i]) != NULL; i++)
3585       m_args.push_back(arg);
3586     m_task.StartExceptionThread(unmask_signals, launch_err);
3587
3588     if (launch_err.Fail()) {
3589       if (launch_err.AsString() == NULL)
3590         launch_err.SetErrorString("unable to start the exception thread");
3591       DNBLog("Could not get inferior's Mach exception port, sending ptrace "
3592              "PT_KILL and exiting.");
3593       ::ptrace(PT_KILL, m_pid, 0, 0);
3594       m_pid = INVALID_NUB_PROCESS;
3595       return INVALID_NUB_PROCESS;
3596     }
3597
3598     StartSTDIOThread();
3599     SetState(eStateAttaching);
3600     DNBLog("[LaunchAttach] (%d) About to ptrace(PT_ATTACHEXC, %d)...", getpid(),
3601            m_pid);
3602     int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
3603     DNBLog("[LaunchAttach] (%d) Completed ptrace(PT_ATTACHEXC, %d) == %d",
3604            getpid(), m_pid, err);
3605     if (err == 0) {
3606       m_flags |= eMachProcessFlagsAttached;
3607       DNBLogThreadedIf(LOG_PROCESS, "successfully attached to pid %d", m_pid);
3608     } else {
3609       SetState(eStateExited);
3610       DNBLogThreadedIf(LOG_PROCESS, "error: failed to attach to pid %d", m_pid);
3611     }
3612   }
3613   return m_pid;
3614 }
3615
3616 #include <servers/bootstrap.h>
3617
3618 pid_t MachProcess::SBForkChildForPTraceDebugging(
3619     const char *app_bundle_path, char const *argv[], char const *envp[],
3620     bool no_stdio, MachProcess *process, DNBError &launch_err) {
3621   DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
3622                    app_bundle_path, process);
3623   CFAllocatorRef alloc = kCFAllocatorDefault;
3624
3625   if (argv[0] == NULL)
3626     return INVALID_NUB_PROCESS;
3627
3628   size_t argc = 0;
3629   // Count the number of arguments
3630   while (argv[argc] != NULL)
3631     argc++;
3632
3633   // Enumerate the arguments
3634   size_t first_launch_arg_idx = 1;
3635   CFReleaser<CFMutableArrayRef> launch_argv;
3636
3637   if (argv[first_launch_arg_idx]) {
3638     size_t launch_argc = argc > 0 ? argc - 1 : 0;
3639     launch_argv.reset(
3640         ::CFArrayCreateMutable(alloc, launch_argc, &kCFTypeArrayCallBacks));
3641     size_t i;
3642     char const *arg;
3643     CFString launch_arg;
3644     for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
3645          i++) {
3646       launch_arg.reset(
3647           ::CFStringCreateWithCString(alloc, arg, kCFStringEncodingUTF8));
3648       if (launch_arg.get() != NULL)
3649         CFArrayAppendValue(launch_argv.get(), launch_arg.get());
3650       else
3651         break;
3652     }
3653   }
3654
3655   // Next fill in the arguments dictionary.  Note, the envp array is of the form
3656   // Variable=value but SpringBoard wants a CF dictionary.  So we have to
3657   // convert
3658   // this here.
3659
3660   CFReleaser<CFMutableDictionaryRef> launch_envp;
3661
3662   if (envp[0]) {
3663     launch_envp.reset(
3664         ::CFDictionaryCreateMutable(alloc, 0, &kCFTypeDictionaryKeyCallBacks,
3665                                     &kCFTypeDictionaryValueCallBacks));
3666     const char *value;
3667     int name_len;
3668     CFString name_string, value_string;
3669
3670     for (int i = 0; envp[i] != NULL; i++) {
3671       value = strstr(envp[i], "=");
3672
3673       // If the name field is empty or there's no =, skip it.  Somebody's
3674       // messing with us.
3675       if (value == NULL || value == envp[i])
3676         continue;
3677
3678       name_len = value - envp[i];
3679
3680       // Now move value over the "="
3681       value++;
3682
3683       name_string.reset(
3684           ::CFStringCreateWithBytes(alloc, (const UInt8 *)envp[i], name_len,
3685                                     kCFStringEncodingUTF8, false));
3686       value_string.reset(
3687           ::CFStringCreateWithCString(alloc, value, kCFStringEncodingUTF8));
3688       CFDictionarySetValue(launch_envp.get(), name_string.get(),
3689                            value_string.get());
3690     }
3691   }
3692
3693   CFString stdio_path;
3694
3695   PseudoTerminal pty;
3696   if (!no_stdio) {
3697     PseudoTerminal::Status pty_err =
3698         pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY);
3699     if (pty_err == PseudoTerminal::success) {
3700       const char *secondary_name = pty.SecondaryName();
3701       DNBLogThreadedIf(LOG_PROCESS,
3702                        "%s() successfully opened primary pty, secondary is %s",
3703                        __FUNCTION__, secondary_name);
3704       if (secondary_name && secondary_name[0]) {
3705         ::chmod(secondary_name, S_IRWXU | S_IRWXG | S_IRWXO);
3706         stdio_path.SetFileSystemRepresentation(secondary_name);
3707       }
3708     }
3709   }
3710
3711   if (stdio_path.get() == NULL) {
3712     stdio_path.SetFileSystemRepresentation("/dev/null");
3713   }
3714
3715   CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
3716   if (bundleIDCFStr == NULL)
3717     return INVALID_NUB_PROCESS;
3718
3719   // This is just for logging:
3720   std::string bundleID;
3721   CFString::UTF8(bundleIDCFStr, bundleID);
3722
3723   DNBLogThreadedIf(LOG_PROCESS, "%s() serialized launch arg array",
3724                    __FUNCTION__);
3725
3726   // Find SpringBoard
3727   SBSApplicationLaunchError sbs_error = 0;
3728   sbs_error = SBSLaunchApplicationForDebugging(
3729       bundleIDCFStr,
3730       (CFURLRef)NULL, // openURL
3731       launch_argv.get(),
3732       launch_envp.get(), // CFDictionaryRef environment
3733       stdio_path.get(), stdio_path.get(),
3734       SBSApplicationLaunchWaitForDebugger | SBSApplicationLaunchUnlockDevice);
3735
3736   launch_err.SetError(sbs_error, DNBError::SpringBoard);
3737
3738   if (sbs_error == SBSApplicationLaunchErrorSuccess) {
3739     static const useconds_t pid_poll_interval = 200000;
3740     static const useconds_t pid_poll_timeout = 30000000;
3741
3742     useconds_t pid_poll_total = 0;
3743
3744     nub_process_t pid = INVALID_NUB_PROCESS;
3745     Boolean pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
3746     // Poll until the process is running, as long as we are getting valid
3747     // responses and the timeout hasn't expired
3748     // A return PID of 0 means the process is not running, which may be because
3749     // it hasn't been (asynchronously) started
3750     // yet, or that it died very quickly (if you weren't using waitForDebugger).
3751     while (!pid_found && pid_poll_total < pid_poll_timeout) {
3752       usleep(pid_poll_interval);
3753       pid_poll_total += pid_poll_interval;
3754       DNBLogThreadedIf(LOG_PROCESS,
3755                        "%s() polling Springboard for pid for %s...",
3756                        __FUNCTION__, bundleID.c_str());
3757       pid_found = SBSProcessIDForDisplayIdentifier(bundleIDCFStr, &pid);
3758     }
3759
3760     CFRelease(bundleIDCFStr);
3761     if (pid_found) {
3762       if (process != NULL) {
3763         // Release our primary pty file descriptor so the pty class doesn't
3764         // close it and so we can continue to use it in our STDIO thread
3765         int primary_fd = pty.ReleasePrimaryFD();
3766         process->SetChildFileDescriptors(primary_fd, primary_fd, primary_fd);
3767       }
3768       DNBLogThreadedIf(LOG_PROCESS, "%s() => pid = %4.4x", __FUNCTION__, pid);
3769     } else {
3770       DNBLogError("failed to lookup the process ID for CFBundleIdentifier %s.",
3771                   bundleID.c_str());
3772     }
3773     return pid;
3774   }
3775
3776   DNBLogError("unable to launch the application with CFBundleIdentifier '%s' "
3777               "sbs_error = %u",
3778               bundleID.c_str(), sbs_error);
3779   return INVALID_NUB_PROCESS;
3780 }
3781
3782 #endif // #ifdef WITH_SPRINGBOARD
3783
3784 #if defined(WITH_BKS) || defined(WITH_FBS)
3785 pid_t MachProcess::BoardServiceLaunchForDebug(
3786     const char *path, char const *argv[], char const *envp[], bool no_stdio,
3787     bool disable_aslr, const char *event_data, bool unmask_signals,
3788     DNBError &launch_err) {
3789   DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv)", __FUNCTION__, path);
3790
3791   // Fork a child process for debugging
3792   SetState(eStateLaunching);
3793   m_pid = BoardServiceForkChildForPTraceDebugging(
3794       path, argv, envp, no_stdio, disable_aslr, event_data, launch_err);
3795   if (m_pid != 0) {
3796     m_path = path;
3797     size_t i;
3798     char const *arg;
3799     for (i = 0; (arg = argv[i]) != NULL; i++)
3800       m_args.push_back(arg);
3801     m_task.StartExceptionThread(unmask_signals, launch_err);
3802
3803     if (launch_err.Fail()) {
3804       if (launch_err.AsString() == NULL)
3805         launch_err.SetErrorString("unable to start the exception thread");
3806       DNBLog("[LaunchAttach] END (%d) Could not get inferior's Mach exception "
3807              "port, "
3808              "sending ptrace "
3809              "PT_KILL to pid %i and exiting.",
3810              getpid(), m_pid);
3811       ::ptrace(PT_KILL, m_pid, 0, 0);
3812       m_pid = INVALID_NUB_PROCESS;
3813       return INVALID_NUB_PROCESS;
3814     }
3815
3816     StartSTDIOThread();
3817     SetState(eStateAttaching);
3818     DNBLog("[LaunchAttach] (%d) About to ptrace(PT_ATTACHEXC, %d)...", getpid(),
3819            m_pid);
3820     int err = ::ptrace(PT_ATTACHEXC, m_pid, 0, 0);
3821     DNBLog("[LaunchAttach] (%d) Completed ptrace(PT_ATTACHEXC, %d) == %d",
3822            getpid(), m_pid, err);
3823     if (err == 0) {
3824       m_flags |= eMachProcessFlagsAttached;
3825       DNBLog("[LaunchAttach] successfully attached to pid %d", m_pid);
3826     } else {
3827       SetState(eStateExited);
3828       DNBLog("[LaunchAttach] END (%d) error: failed to attach to pid %d",
3829              getpid(), m_pid);
3830     }
3831   }
3832   return m_pid;
3833 }
3834
3835 pid_t MachProcess::BoardServiceForkChildForPTraceDebugging(
3836     const char *app_bundle_path, char const *argv[], char const *envp[],
3837     bool no_stdio, bool disable_aslr, const char *event_data,
3838     DNBError &launch_err) {
3839   if (argv[0] == NULL)
3840     return INVALID_NUB_PROCESS;
3841
3842   DNBLogThreadedIf(LOG_PROCESS, "%s( '%s', argv, %p)", __FUNCTION__,
3843                    app_bundle_path, this);
3844
3845   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
3846
3847   size_t argc = 0;
3848   // Count the number of arguments
3849   while (argv[argc] != NULL)
3850     argc++;
3851
3852   // Enumerate the arguments
3853   size_t first_launch_arg_idx = 1;
3854
3855   NSMutableArray *launch_argv = nil;
3856
3857   if (argv[first_launch_arg_idx]) {
3858     size_t launch_argc = argc > 0 ? argc - 1 : 0;
3859     launch_argv = [NSMutableArray arrayWithCapacity:launch_argc];
3860     size_t i;
3861     char const *arg;
3862     NSString *launch_arg;
3863     for (i = first_launch_arg_idx; (i < argc) && ((arg = argv[i]) != NULL);
3864          i++) {
3865       launch_arg = [NSString stringWithUTF8String:arg];
3866       // FIXME: Should we silently eat an argument that we can't convert into a
3867       // UTF8 string?
3868       if (launch_arg != nil)
3869         [launch_argv addObject:launch_arg];
3870       else
3871         break;
3872     }
3873   }
3874
3875   NSMutableDictionary *launch_envp = nil;
3876   if (envp[0]) {
3877     launch_envp = [[NSMutableDictionary alloc] init];
3878     const char *value;
3879     int name_len;
3880     NSString *name_string, *value_string;
3881
3882     for (int i = 0; envp[i] != NULL; i++) {
3883       value = strstr(envp[i], "=");
3884
3885       // If the name field is empty or there's no =, skip it.  Somebody's
3886       // messing with us.
3887       if (value == NULL || value == envp[i])
3888         continue;
3889
3890       name_len = value - envp[i];
3891
3892       // Now move value over the "="
3893       value++;
3894       name_string = [[NSString alloc] initWithBytes:envp[i]
3895                                              length:name_len
3896                                            encoding:NSUTF8StringEncoding];
3897       value_string = [NSString stringWithUTF8String:value];
3898       [launch_envp setObject:value_string forKey:name_string];
3899     }
3900   }
3901
3902   NSString *stdio_path = nil;
3903   NSFileManager *file_manager = [NSFileManager defaultManager];
3904
3905   PseudoTerminal pty;
3906   if (!no_stdio) {
3907     PseudoTerminal::Status pty_err =
3908         pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY);
3909     if (pty_err == PseudoTerminal::success) {
3910       const char *secondary_name = pty.SecondaryName();
3911       DNBLogThreadedIf(LOG_PROCESS,
3912                        "%s() successfully opened primary pty, secondary is %s",
3913                        __FUNCTION__, secondary_name);
3914       if (secondary_name && secondary_name[0]) {
3915         ::chmod(secondary_name, S_IRWXU | S_IRWXG | S_IRWXO);
3916         stdio_path = [file_manager
3917             stringWithFileSystemRepresentation:secondary_name
3918                                         length:strlen(secondary_name)];
3919       }
3920     }
3921   }
3922
3923   if (stdio_path == nil) {
3924     const char *null_path = "/dev/null";
3925     stdio_path =
3926         [file_manager stringWithFileSystemRepresentation:null_path
3927                                                   length:strlen(null_path)];
3928   }
3929
3930   CFStringRef bundleIDCFStr = CopyBundleIDForPath(app_bundle_path, launch_err);
3931   if (bundleIDCFStr == NULL) {
3932     [pool drain];
3933     return INVALID_NUB_PROCESS;
3934   }
3935
3936   // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
3937   // toll-free bridging here:
3938   NSString *bundleIDNSStr = (NSString *)bundleIDCFStr;
3939
3940   // Okay, now let's assemble all these goodies into the BackBoardServices
3941   // options mega-dictionary:
3942
3943   NSMutableDictionary *options = nullptr;
3944   pid_t return_pid = INVALID_NUB_PROCESS;
3945   bool success = false;
3946
3947 #ifdef WITH_BKS
3948   if (ProcessUsingBackBoard()) {
3949     options =
3950         BKSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
3951                                    stdio_path, disable_aslr, event_data);
3952     success = BKSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
3953                                              &return_pid);
3954   }
3955 #endif
3956 #ifdef WITH_FBS
3957   if (ProcessUsingFrontBoard()) {
3958     options =
3959         FBSCreateOptionsDictionary(app_bundle_path, launch_argv, launch_envp,
3960                                    stdio_path, disable_aslr, event_data);
3961     success = FBSCallOpenApplicationFunction(bundleIDNSStr, options, launch_err,
3962                                              &return_pid);
3963   }
3964 #endif
3965
3966   if (success) {
3967     int primary_fd = pty.ReleasePrimaryFD();
3968     SetChildFileDescriptors(primary_fd, primary_fd, primary_fd);
3969     CFString::UTF8(bundleIDCFStr, m_bundle_id);
3970   }
3971
3972   [pool drain];
3973
3974   return return_pid;
3975 }
3976
3977 bool MachProcess::BoardServiceSendEvent(const char *event_data,
3978                                         DNBError &send_err) {
3979   bool return_value = true;
3980
3981   if (event_data == NULL || *event_data == '\0') {
3982     DNBLogError("SendEvent called with NULL event data.");
3983     send_err.SetErrorString("SendEvent called with empty event data");
3984     return false;
3985   }
3986
3987   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
3988
3989   if (strcmp(event_data, "BackgroundApplication") == 0) {
3990 // This is an event I cooked up.  What you actually do is foreground the system
3991 // app, so:
3992 #ifdef WITH_BKS
3993     if (ProcessUsingBackBoard()) {
3994       return_value = BKSCallOpenApplicationFunction(nil, nil, send_err, NULL);
3995     }
3996 #endif
3997 #ifdef WITH_FBS
3998     if (ProcessUsingFrontBoard()) {
3999       return_value = FBSCallOpenApplicationFunction(nil, nil, send_err, NULL);
4000     }
4001 #endif
4002     if (!return_value) {
4003       DNBLogError("Failed to background application, error: %s.",
4004                   send_err.AsString());
4005     }
4006   } else {
4007     if (m_bundle_id.empty()) {
4008       // See if we can figure out the bundle ID for this PID:
4009
4010       DNBLogError(
4011           "Tried to send event \"%s\" to a process that has no bundle ID.",
4012           event_data);
4013       return false;
4014     }
4015
4016     NSString *bundleIDNSStr =
4017         [NSString stringWithUTF8String:m_bundle_id.c_str()];
4018
4019     NSMutableDictionary *options = [NSMutableDictionary dictionary];
4020
4021 #ifdef WITH_BKS
4022     if (ProcessUsingBackBoard()) {
4023       if (!BKSAddEventDataToOptions(options, event_data, send_err)) {
4024         [pool drain];
4025         return false;
4026       }
4027       return_value = BKSCallOpenApplicationFunction(bundleIDNSStr, options,
4028                                                     send_err, NULL);
4029       DNBLogThreadedIf(LOG_PROCESS,
4030                        "Called BKSCallOpenApplicationFunction to send event.");
4031     }
4032 #endif
4033 #ifdef WITH_FBS
4034     if (ProcessUsingFrontBoard()) {
4035       if (!FBSAddEventDataToOptions(options, event_data, send_err)) {
4036         [pool drain];
4037         return false;
4038       }
4039       return_value = FBSCallOpenApplicationFunction(bundleIDNSStr, options,
4040                                                     send_err, NULL);
4041       DNBLogThreadedIf(LOG_PROCESS,
4042                        "Called FBSCallOpenApplicationFunction to send event.");
4043     }
4044 #endif
4045
4046     if (!return_value) {
4047       DNBLogError("Failed to send event: %s, error: %s.", event_data,
4048                   send_err.AsString());
4049     }
4050   }
4051
4052   [pool drain];
4053   return return_value;
4054 }
4055 #endif // defined(WITH_BKS) || defined (WITH_FBS)
4056
4057 #ifdef WITH_BKS
4058 void MachProcess::BKSCleanupAfterAttach(const void *attach_token,
4059                                         DNBError &err_str) {
4060   bool success;
4061
4062   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
4063
4064   // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
4065   // toll-free bridging here:
4066   NSString *bundleIDNSStr = (NSString *)attach_token;
4067
4068   // Okay, now let's assemble all these goodies into the BackBoardServices
4069   // options mega-dictionary:
4070
4071   // First we have the debug sub-dictionary:
4072   NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
4073   [debug_options setObject:[NSNumber numberWithBool:YES]
4074                     forKey:BKSDebugOptionKeyCancelDebugOnNextLaunch];
4075
4076   // That will go in the overall dictionary:
4077
4078   NSMutableDictionary *options = [NSMutableDictionary dictionary];
4079   [options setObject:debug_options
4080               forKey:BKSOpenApplicationOptionKeyDebuggingOptions];
4081
4082   success =
4083       BKSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
4084
4085   if (!success) {
4086     DNBLogError("error trying to cancel debug on next launch for %s: %s",
4087                 [bundleIDNSStr UTF8String], err_str.AsString());
4088   }
4089
4090   [pool drain];
4091 }
4092 #endif // WITH_BKS
4093
4094 #ifdef WITH_FBS
4095 void MachProcess::FBSCleanupAfterAttach(const void *attach_token,
4096                                         DNBError &err_str) {
4097   bool success;
4098
4099   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
4100
4101   // Instead of rewriting CopyBundleIDForPath for NSStrings, we'll just use
4102   // toll-free bridging here:
4103   NSString *bundleIDNSStr = (NSString *)attach_token;
4104
4105   // Okay, now let's assemble all these goodies into the BackBoardServices
4106   // options mega-dictionary:
4107
4108   // First we have the debug sub-dictionary:
4109   NSMutableDictionary *debug_options = [NSMutableDictionary dictionary];
4110   [debug_options setObject:[NSNumber numberWithBool:YES]
4111                     forKey:FBSDebugOptionKeyCancelDebugOnNextLaunch];
4112
4113   // That will go in the overall dictionary:
4114
4115   NSMutableDictionary *options = [NSMutableDictionary dictionary];
4116   [options setObject:debug_options
4117               forKey:FBSOpenApplicationOptionKeyDebuggingOptions];
4118
4119   success =
4120       FBSCallOpenApplicationFunction(bundleIDNSStr, options, err_str, NULL);
4121
4122   if (!success) {
4123     DNBLogError("error trying to cancel debug on next launch for %s: %s",
4124                 [bundleIDNSStr UTF8String], err_str.AsString());
4125   }
4126
4127   [pool drain];
4128 }
4129 #endif // WITH_FBS
4130
4131
4132 void MachProcess::CalculateBoardStatus()
4133 {
4134   if (m_flags & eMachProcessFlagsBoardCalculated)
4135     return;
4136   if (m_pid == 0)
4137     return;
4138
4139 #if defined (WITH_FBS) || defined (WITH_BKS)
4140     bool found_app_flavor = false;
4141 #endif
4142
4143 #if defined(WITH_FBS)
4144     if (!found_app_flavor && IsFBSProcess(m_pid)) {
4145       found_app_flavor = true;
4146       m_flags |= eMachProcessFlagsUsingFBS;
4147     }
4148 #endif
4149 #if defined(WITH_BKS)
4150     if (!found_app_flavor && IsBKSProcess(m_pid)) {
4151       found_app_flavor = true;
4152       m_flags |= eMachProcessFlagsUsingBKS;
4153     }
4154 #endif
4155
4156     m_flags |= eMachProcessFlagsBoardCalculated;
4157 }
4158
4159 bool MachProcess::ProcessUsingBackBoard() {
4160   CalculateBoardStatus();
4161   return (m_flags & eMachProcessFlagsUsingBKS) != 0;
4162 }
4163
4164 bool MachProcess::ProcessUsingFrontBoard() {
4165   CalculateBoardStatus();
4166   return (m_flags & eMachProcessFlagsUsingFBS) != 0;
4167 }
4168
4169 int MachProcess::GetInferiorAddrSize(pid_t pid) {
4170   int pointer_size = 8;
4171   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
4172   struct kinfo_proc processInfo;
4173   size_t bufsize = sizeof(processInfo);
4174   if (sysctl(mib, (unsigned)(sizeof(mib) / sizeof(int)), &processInfo, &bufsize,
4175              NULL, 0) == 0 &&
4176       bufsize > 0) {
4177     if ((processInfo.kp_proc.p_flag & P_LP64) == 0)
4178       pointer_size = 4;
4179   }
4180   return pointer_size;
4181 }