| //===-- DarwinProcessLauncher.cpp -------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // |
| // DarwinProcessLauncher.cpp |
| // lldb |
| // |
| // Created by Todd Fiala on 8/30/16. |
| // |
| // |
| |
| #include "DarwinProcessLauncher.h" |
| |
| // C includes |
| #include <spawn.h> |
| #include <sys/ptrace.h> |
| #include <sys/stat.h> |
| #include <sys/sysctl.h> |
| |
| #ifndef _POSIX_SPAWN_DISABLE_ASLR |
| #define _POSIX_SPAWN_DISABLE_ASLR 0x0100 |
| #endif |
| |
| // LLDB includes |
| #include "lldb/lldb-enumerations.h" |
| |
| #include "lldb/Host/PseudoTerminal.h" |
| #include "lldb/Target/ProcessLaunchInfo.h" |
| #include "lldb/Utility/Log.h" |
| #include "lldb/Utility/Status.h" |
| #include "lldb/Utility/StreamString.h" |
| #include "llvm/Support/Errno.h" |
| |
| #include "CFBundle.h" |
| #include "CFString.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| using namespace lldb_private::process_darwin; |
| using namespace lldb_private::darwin_process_launcher; |
| |
| namespace { |
| static LaunchFlavor g_launch_flavor = LaunchFlavor::Default; |
| } |
| |
| namespace lldb_private { |
| namespace darwin_process_launcher { |
| |
| static uint32_t GetCPUTypeForLocalProcess(::pid_t pid) { |
| int mib[CTL_MAXNAME] = { |
| 0, |
| }; |
| size_t len = CTL_MAXNAME; |
| if (::sysctlnametomib("sysctl.proc_cputype", mib, &len)) |
| return 0; |
| |
| mib[len] = pid; |
| len++; |
| |
| cpu_type_t cpu; |
| size_t cpu_len = sizeof(cpu); |
| if (::sysctl(mib, static_cast<u_int>(len), &cpu, &cpu_len, 0, 0)) |
| cpu = 0; |
| return cpu; |
| } |
| |
| static bool ResolveExecutablePath(const char *path, char *resolved_path, |
| size_t resolved_path_size) { |
| if (path == NULL || path[0] == '\0') |
| return false; |
| |
| char max_path[PATH_MAX]; |
| std::string result; |
| CFString::GlobPath(path, result); |
| |
| if (result.empty()) |
| result = path; |
| |
| struct stat path_stat; |
| if (::stat(path, &path_stat) == 0) { |
| if ((path_stat.st_mode & S_IFMT) == S_IFDIR) { |
| CFBundle bundle(path); |
| CFReleaser<CFURLRef> url(bundle.CopyExecutableURL()); |
| if (url.get()) { |
| if (::CFURLGetFileSystemRepresentation( |
| url.get(), true, (UInt8 *)resolved_path, resolved_path_size)) |
| return true; |
| } |
| } |
| } |
| |
| if (realpath(path, max_path)) { |
| // Found the path relatively... |
| ::strncpy(resolved_path, max_path, resolved_path_size); |
| return strlen(resolved_path) + 1 < resolved_path_size; |
| } else { |
| // Not a relative path, check the PATH environment variable if the |
| const char *PATH = getenv("PATH"); |
| if (PATH) { |
| const char *curr_path_start = PATH; |
| const char *curr_path_end; |
| while (curr_path_start && *curr_path_start) { |
| curr_path_end = strchr(curr_path_start, ':'); |
| if (curr_path_end == NULL) { |
| result.assign(curr_path_start); |
| curr_path_start = NULL; |
| } else if (curr_path_end > curr_path_start) { |
| size_t len = curr_path_end - curr_path_start; |
| result.assign(curr_path_start, len); |
| curr_path_start += len + 1; |
| } else |
| break; |
| |
| result += '/'; |
| result += path; |
| struct stat s; |
| if (stat(result.c_str(), &s) == 0) { |
| ::strncpy(resolved_path, result.c_str(), resolved_path_size); |
| return result.size() + 1 < resolved_path_size; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| // TODO check if we have a general purpose fork and exec. We may be |
| // able to get rid of this entirely. |
| static Status ForkChildForPTraceDebugging(const char *path, char const *argv[], |
| char const *envp[], ::pid_t *pid, |
| int *pty_fd) { |
| Status error; |
| if (!path || !argv || !envp || !pid || !pty_fd) { |
| error.SetErrorString("invalid arguments"); |
| return error; |
| } |
| |
| // Use a fork that ties the child process's stdin/out/err to a pseudo |
| // terminal so we can read it in our MachProcess::STDIOThread as unbuffered |
| // io. |
| PseudoTerminal pty; |
| char fork_error[256]; |
| memset(fork_error, 0, sizeof(fork_error)); |
| *pid = static_cast<::pid_t>(pty.Fork(fork_error, sizeof(fork_error))); |
| if (*pid < 0) { |
| //-------------------------------------------------------------- |
| // Status during fork. |
| //-------------------------------------------------------------- |
| *pid = static_cast<::pid_t>(LLDB_INVALID_PROCESS_ID); |
| error.SetErrorStringWithFormat("%s(): fork failed: %s", __FUNCTION__, |
| fork_error); |
| return error; |
| } else if (pid == 0) { |
| //-------------------------------------------------------------- |
| // Child process |
| //-------------------------------------------------------------- |
| |
| // Debug this process. |
| ::ptrace(PT_TRACE_ME, 0, 0, 0); |
| |
| // Get BSD signals as mach exceptions. |
| ::ptrace(PT_SIGEXC, 0, 0, 0); |
| |
| // If our parent is setgid, lets make sure we don't inherit those extra |
| // powers due to nepotism. |
| if (::setgid(getgid()) == 0) { |
| // Let the child have its own process group. We need to execute this call |
| // in both the child and parent to avoid a race condition between the two |
| // processes. |
| |
| // Set the child process group to match its pid. |
| ::setpgid(0, 0); |
| |
| // Sleep a bit to before the exec call. |
| ::sleep(1); |
| |
| // Turn this process into the given executable. |
| ::execv(path, (char *const *)argv); |
| } |
| // Exit with error code. Child process should have taken over in above exec |
| // call and if the exec fails it will exit the child process below. |
| ::exit(127); |
| } else { |
| //-------------------------------------------------------------- |
| // Parent process |
| //-------------------------------------------------------------- |
| // Let the child have its own process group. We need to execute this call |
| // in both the child and parent to avoid a race condition between the two |
| // processes. |
| |
| // Set the child process group to match its pid |
| ::setpgid(*pid, *pid); |
| if (pty_fd) { |
| // Release our master pty file descriptor so the pty class doesn't close |
| // it and so we can continue to use it in our STDIO thread |
| *pty_fd = pty.ReleaseMasterFileDescriptor(); |
| } |
| } |
| return error; |
| } |
| |
| static Status |
| CreatePosixSpawnFileAction(const FileAction &action, |
| posix_spawn_file_actions_t *file_actions) { |
| Status error; |
| |
| // Log it. |
| Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); |
| if (log) { |
| StreamString stream; |
| stream.PutCString("converting file action for posix_spawn(): "); |
| action.Dump(stream); |
| stream.Flush(); |
| log->PutCString(stream.GetString().c_str()); |
| } |
| |
| // Validate args. |
| if (!file_actions) { |
| error.SetErrorString("mandatory file_actions arg is null"); |
| return error; |
| } |
| |
| // Build the posix file action. |
| switch (action.GetAction()) { |
| case FileAction::eFileActionOpen: { |
| const int error_code = ::posix_spawn_file_actions_addopen( |
| file_actions, action.GetFD(), action.GetPath(), |
| action.GetActionArgument(), 0); |
| if (error_code != 0) { |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| break; |
| } |
| |
| case FileAction::eFileActionClose: { |
| const int error_code = |
| ::posix_spawn_file_actions_addclose(file_actions, action.GetFD()); |
| if (error_code != 0) { |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| break; |
| } |
| |
| case FileAction::eFileActionDuplicate: { |
| const int error_code = ::posix_spawn_file_actions_adddup2( |
| file_actions, action.GetFD(), action.GetActionArgument()); |
| if (error_code != 0) { |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| break; |
| } |
| |
| case FileAction::eFileActionNone: |
| default: |
| if (log) |
| log->Printf("%s(): unsupported file action %u", __FUNCTION__, |
| action.GetAction()); |
| break; |
| } |
| |
| return error; |
| } |
| |
| static Status PosixSpawnChildForPTraceDebugging(const char *path, |
| ProcessLaunchInfo &launch_info, |
| ::pid_t *pid, |
| cpu_type_t *actual_cpu_type) { |
| Status error; |
| Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); |
| |
| if (!pid) { |
| error.SetErrorStringWithFormat("%s(): pid arg cannot be null", |
| __FUNCTION__); |
| return error; |
| } |
| |
| posix_spawnattr_t attr; |
| short flags; |
| if (log) { |
| StreamString stream; |
| stream.Printf("%s(path='%s',...)\n", __FUNCTION__, path); |
| launch_info.Dump(stream, nullptr); |
| stream.Flush(); |
| log->PutCString(stream.GetString().c_str()); |
| } |
| |
| int error_code; |
| if ((error_code = ::posix_spawnattr_init(&attr)) != 0) { |
| if (log) |
| log->Printf("::posix_spawnattr_init(&attr) failed"); |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| |
| // Ensure we clean up the spawnattr structure however we exit this function. |
| std::unique_ptr<posix_spawnattr_t, int (*)(posix_spawnattr_t *)> spawnattr_up( |
| &attr, ::posix_spawnattr_destroy); |
| |
| flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETSIGDEF | |
| POSIX_SPAWN_SETSIGMASK; |
| if (launch_info.GetFlags().Test(eLaunchFlagDisableASLR)) |
| flags |= _POSIX_SPAWN_DISABLE_ASLR; |
| |
| sigset_t no_signals; |
| sigset_t all_signals; |
| sigemptyset(&no_signals); |
| sigfillset(&all_signals); |
| ::posix_spawnattr_setsigmask(&attr, &no_signals); |
| ::posix_spawnattr_setsigdefault(&attr, &all_signals); |
| |
| if ((error_code = ::posix_spawnattr_setflags(&attr, flags)) != 0) { |
| LLDB_LOG(log, |
| "::posix_spawnattr_setflags(&attr, " |
| "POSIX_SPAWN_START_SUSPENDED{0}) failed: {1}", |
| flags & _POSIX_SPAWN_DISABLE_ASLR ? " | _POSIX_SPAWN_DISABLE_ASLR" |
| : "", |
| llvm::sys::StrError(error_code)); |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| |
| #if !defined(__arm__) |
| |
| // We don't need to do this for ARM, and we really shouldn't now that we have |
| // multiple CPU subtypes and no posix_spawnattr call that allows us to set |
| // which CPU subtype to launch... |
| cpu_type_t desired_cpu_type = launch_info.GetArchitecture().GetMachOCPUType(); |
| if (desired_cpu_type != LLDB_INVALID_CPUTYPE) { |
| size_t ocount = 0; |
| error_code = |
| ::posix_spawnattr_setbinpref_np(&attr, 1, &desired_cpu_type, &ocount); |
| if (error_code != 0) { |
| LLDB_LOG(log, |
| "::posix_spawnattr_setbinpref_np(&attr, 1, " |
| "cpu_type = {0:x8}, count => {1}): {2}", |
| desired_cpu_type, ocount, llvm::sys::StrError(error_code)); |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| if (ocount != 1) { |
| error.SetErrorStringWithFormat("posix_spawnattr_setbinpref_np " |
| "did not set the expected number " |
| "of cpu_type entries: expected 1 " |
| "but was %zu", |
| ocount); |
| return error; |
| } |
| } |
| #endif |
| |
| posix_spawn_file_actions_t file_actions; |
| if ((error_code = ::posix_spawn_file_actions_init(&file_actions)) != 0) { |
| LLDB_LOG(log, "::posix_spawn_file_actions_init(&file_actions) failed: {0}", |
| llvm::sys::StrError(error_code)); |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| |
| // Ensure we clean up file actions however we exit this. When the |
| // file_actions_up below goes out of scope, we'll get our file action |
| // cleanup. |
| std::unique_ptr<posix_spawn_file_actions_t, |
| int (*)(posix_spawn_file_actions_t *)> |
| file_actions_up(&file_actions, ::posix_spawn_file_actions_destroy); |
| |
| // We assume the caller has setup the file actions appropriately. We are not |
| // in the business of figuring out what we really need here. lldb-server will |
| // have already called FinalizeFileActions() as well to button these up |
| // properly. |
| const size_t num_actions = launch_info.GetNumFileActions(); |
| for (size_t action_index = 0; action_index < num_actions; ++action_index) { |
| const FileAction *const action = |
| launch_info.GetFileActionAtIndex(action_index); |
| if (!action) |
| continue; |
| |
| error = CreatePosixSpawnFileAction(*action, &file_actions); |
| if (!error.Success()) { |
| if (log) |
| log->Printf("%s(): error converting FileAction to posix_spawn " |
| "file action: %s", |
| __FUNCTION__, error.AsCString()); |
| return error; |
| } |
| } |
| |
| // TODO: Verify if we can set the working directory back immediately |
| // after the posix_spawnp call without creating a race condition??? |
| const char *const working_directory = |
| launch_info.GetWorkingDirectory().GetCString(); |
| if (working_directory && working_directory[0]) |
| ::chdir(working_directory); |
| |
| auto argv = launch_info.GetArguments().GetArgumentVector(); |
| auto envp = launch_info.GetEnvironmentEntries().GetArgumentVector(); |
| error_code = ::posix_spawnp(pid, path, &file_actions, &attr, |
| (char *const *)argv, (char *const *)envp); |
| if (error_code != 0) { |
| LLDB_LOG(log, |
| "::posix_spawnp(pid => {0}, path = '{1}', file_actions " |
| "= {2}, attr = {3}, argv = {4}, envp = {5}) failed: {6}", |
| pid, path, &file_actions, &attr, argv, envp, |
| llvm::sys::StrError(error_code)); |
| error.SetError(error_code, eErrorTypePOSIX); |
| return error; |
| } |
| |
| // Validate we got a pid. |
| if (pid == LLDB_INVALID_PROCESS_ID) { |
| error.SetErrorString("posix_spawn() did not indicate a failure but it " |
| "failed to return a pid, aborting."); |
| return error; |
| } |
| |
| if (actual_cpu_type) { |
| *actual_cpu_type = GetCPUTypeForLocalProcess(*pid); |
| if (log) |
| log->Printf("%s(): cpu type for launched process pid=%i: " |
| "cpu_type=0x%8.8x", |
| __FUNCTION__, *pid, *actual_cpu_type); |
| } |
| |
| return error; |
| } |
| |
| Status LaunchInferior(ProcessLaunchInfo &launch_info, int *pty_master_fd, |
| LaunchFlavor *launch_flavor) { |
| Status error; |
| Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); |
| |
| if (!launch_flavor) { |
| error.SetErrorString("mandatory launch_flavor field was null"); |
| return error; |
| } |
| |
| if (log) { |
| StreamString stream; |
| stream.Printf("NativeProcessDarwin::%s(): launching with the " |
| "following launch info:", |
| __FUNCTION__); |
| launch_info.Dump(stream, nullptr); |
| stream.Flush(); |
| log->PutCString(stream.GetString().c_str()); |
| } |
| |
| // Retrieve the binary name given to us. |
| char given_path[PATH_MAX]; |
| given_path[0] = '\0'; |
| launch_info.GetExecutableFile().GetPath(given_path, sizeof(given_path)); |
| |
| // Determine the manner in which we'll launch. |
| *launch_flavor = g_launch_flavor; |
| if (*launch_flavor == LaunchFlavor::Default) { |
| // Our default launch method is posix spawn |
| *launch_flavor = LaunchFlavor::PosixSpawn; |
| #if defined WITH_FBS |
| // Check if we have an app bundle, if so launch using BackBoard Services. |
| if (strstr(given_path, ".app")) { |
| *launch_flavor = eLaunchFlavorFBS; |
| } |
| #elif defined WITH_BKS |
| // Check if we have an app bundle, if so launch using BackBoard Services. |
| if (strstr(given_path, ".app")) { |
| *launch_flavor = eLaunchFlavorBKS; |
| } |
| #elif defined WITH_SPRINGBOARD |
| // Check if we have an app bundle, if so launch using SpringBoard. |
| if (strstr(given_path, ".app")) { |
| *launch_flavor = eLaunchFlavorSpringBoard; |
| } |
| #endif |
| } |
| |
| // Attempt to resolve the binary name to an absolute path. |
| char resolved_path[PATH_MAX]; |
| resolved_path[0] = '\0'; |
| |
| if (log) |
| log->Printf("%s(): attempting to resolve given binary path: \"%s\"", |
| __FUNCTION__, given_path); |
| |
| // If we fail to resolve the path to our executable, then just use what we |
| // were given and hope for the best |
| if (!ResolveExecutablePath(given_path, resolved_path, |
| sizeof(resolved_path))) { |
| if (log) |
| log->Printf("%s(): failed to resolve binary path, using " |
| "what was given verbatim and hoping for the best", |
| __FUNCTION__); |
| ::strncpy(resolved_path, given_path, sizeof(resolved_path)); |
| } else { |
| if (log) |
| log->Printf("%s(): resolved given binary path to: \"%s\"", __FUNCTION__, |
| resolved_path); |
| } |
| |
| char launch_err_str[PATH_MAX]; |
| launch_err_str[0] = '\0'; |
| |
| // TODO figure out how to handle QSetProcessEvent |
| // const char *process_event = ctx.GetProcessEvent(); |
| |
| // Ensure the binary is there. |
| struct stat path_stat; |
| if (::stat(resolved_path, &path_stat) == -1) { |
| error.SetErrorToErrno(); |
| return error; |
| } |
| |
| // Fork a child process for debugging |
| // state_callback(eStateLaunching); |
| |
| const auto argv = launch_info.GetArguments().GetConstArgumentVector(); |
| const auto envp = |
| launch_info.GetEnvironmentEntries().GetConstArgumentVector(); |
| |
| switch (*launch_flavor) { |
| case LaunchFlavor::ForkExec: { |
| ::pid_t pid = LLDB_INVALID_PROCESS_ID; |
| error = ForkChildForPTraceDebugging(resolved_path, argv, envp, &pid, |
| pty_master_fd); |
| if (error.Success()) { |
| launch_info.SetProcessID(static_cast<lldb::pid_t>(pid)); |
| } else { |
| // Reset any variables that might have been set during a failed launch |
| // attempt. |
| if (pty_master_fd) |
| *pty_master_fd = -1; |
| |
| // We're done. |
| return error; |
| } |
| } break; |
| |
| #ifdef WITH_FBS |
| case LaunchFlavor::FBS: { |
| const char *app_ext = strstr(path, ".app"); |
| if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) { |
| std::string app_bundle_path(path, app_ext + strlen(".app")); |
| m_flags |= eMachProcessFlagsUsingFBS; |
| if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp, |
| no_stdio, disable_aslr, event_data, |
| launch_err) != 0) |
| return m_pid; // A successful SBLaunchForDebug() returns and assigns a |
| // non-zero m_pid. |
| else |
| break; // We tried a FBS launch, but didn't succeed lets get out |
| } |
| } break; |
| #endif |
| |
| #ifdef WITH_BKS |
| case LaunchFlavor::BKS: { |
| const char *app_ext = strstr(path, ".app"); |
| if (app_ext && (app_ext[4] == '\0' || app_ext[4] == '/')) { |
| std::string app_bundle_path(path, app_ext + strlen(".app")); |
| m_flags |= eMachProcessFlagsUsingBKS; |
| if (BoardServiceLaunchForDebug(app_bundle_path.c_str(), argv, envp, |
| no_stdio, disable_aslr, event_data, |
| launch_err) != 0) |
| return m_pid; // A successful SBLaunchForDebug() returns and assigns a |
| // non-zero m_pid. |
| else |
| break; // We tried a BKS launch, but didn't succeed lets get out |
| } |
| } break; |
| #endif |
| |
| #ifdef WITH_SPRINGBOARD |
| case LaunchFlavor::SpringBoard: { |
| // .../whatever.app/whatever ? |
| // Or .../com.apple.whatever.app/whatever -- be careful of ".app" in |
| // "com.apple.whatever" here |
| const char *app_ext = strstr(path, ".app/"); |
| if (app_ext == NULL) { |
| // .../whatever.app ? |
| int len = strlen(path); |
| if (len > 5) { |
| if (strcmp(path + len - 4, ".app") == 0) { |
| app_ext = path + len - 4; |
| } |
| } |
| } |
| if (app_ext) { |
| std::string app_bundle_path(path, app_ext + strlen(".app")); |
| if (SBLaunchForDebug(app_bundle_path.c_str(), argv, envp, no_stdio, |
| disable_aslr, launch_err) != 0) |
| return m_pid; // A successful SBLaunchForDebug() returns and assigns a |
| // non-zero m_pid. |
| else |
| break; // We tried a springboard launch, but didn't succeed lets get out |
| } |
| } break; |
| #endif |
| |
| case LaunchFlavor::PosixSpawn: { |
| ::pid_t pid = LLDB_INVALID_PROCESS_ID; |
| |
| // Retrieve paths for stdin/stdout/stderr. |
| cpu_type_t actual_cpu_type = 0; |
| error = PosixSpawnChildForPTraceDebugging(resolved_path, launch_info, &pid, |
| &actual_cpu_type); |
| if (error.Success()) { |
| launch_info.SetProcessID(static_cast<lldb::pid_t>(pid)); |
| if (pty_master_fd) |
| *pty_master_fd = launch_info.GetPTY().ReleaseMasterFileDescriptor(); |
| } else { |
| // Reset any variables that might have been set during a failed launch |
| // attempt. |
| if (pty_master_fd) |
| *pty_master_fd = -1; |
| |
| // We're done. |
| return error; |
| } |
| break; |
| } |
| |
| default: |
| // Invalid launch flavor. |
| error.SetErrorStringWithFormat("NativeProcessDarwin::%s(): unknown " |
| "launch flavor %d", |
| __FUNCTION__, (int)*launch_flavor); |
| return error; |
| } |
| |
| if (launch_info.GetProcessID() == LLDB_INVALID_PROCESS_ID) { |
| // If we don't have a valid process ID and no one has set the error, then |
| // return a generic error. |
| if (error.Success()) |
| error.SetErrorStringWithFormat("%s(): failed to launch, no reason " |
| "specified", |
| __FUNCTION__); |
| } |
| |
| // We're done with the launch side of the operation. |
| return error; |
| } |
| } |
| } // namespaces |