maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/tools/darwin-debug/darwin-debug.cpp

338 lines
10 KiB
C++
Raw Blame History

//===-- Launcher.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//----------------------------------------------------------------------
// Darwin launch helper
//
// This program was written to allow programs to be launched in a new
// Terminal.app window and have the application be stopped for debugging
// at the program entry point.
//
// Although it uses posix_spawn(), it uses Darwin specific posix spawn
// attribute flags to accomplish its task. It uses an "exec only" flag
// which avoids forking this process, and it uses a "stop at entry"
// flag to stop the program at the entry point.
//
// Since it uses darwin specific flags this code should not be compiled
// on other systems.
//----------------------------------------------------------------------
#if defined(__APPLE__)
#include <crt_externs.h> // for _NSGetEnviron()
#include <getopt.h>
#include <limits.h>
#include <mach/machine.h>
#include <signal.h>
#include <spawn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <string>
#ifndef _POSIX_SPAWN_DISABLE_ASLR
#define _POSIX_SPAWN_DISABLE_ASLR 0x0100
#endif
#define streq(a, b) strcmp(a, b) == 0
static struct option g_long_options[] = {
{"arch", required_argument, NULL, 'a'},
{"disable-aslr", no_argument, NULL, 'd'},
{"no-env", no_argument, NULL, 'e'},
{"help", no_argument, NULL, 'h'},
{"setsid", no_argument, NULL, 's'},
{"unix-socket", required_argument, NULL, 'u'},
{"working-dir", required_argument, NULL, 'w'},
{"env", required_argument, NULL, 'E'},
{NULL, 0, NULL, 0}};
static void usage() {
puts("NAME\n"
" darwin-debug -- posix spawn a process that is stopped at the entry "
"point\n"
" for debugging.\n"
"\n"
"SYNOPSIS\n"
" darwin-debug --unix-socket=<SOCKET> [--arch=<ARCH>] "
"[--working-dir=<PATH>] [--disable-aslr] [--no-env] [--setsid] [--help] "
"-- <PROGRAM> [<PROGRAM-ARG> <PROGRAM-ARG> ....]\n"
"\n"
"DESCRIPTION\n"
" darwin-debug will exec itself into a child process <PROGRAM> that "
"is\n"
" halted for debugging. It does this by using posix_spawn() along "
"with\n"
" darwin specific posix_spawn flags that allows exec only (no fork), "
"and\n"
" stop at the program entry point. Any program arguments "
"<PROGRAM-ARG> are\n"
" passed on to the exec as the arguments for the new process. The "
"current\n"
" environment will be passed to the new process unless the "
"\"--no-env\"\n"
" option is used. A unix socket must be supplied using the\n"
" --unix-socket=<SOCKET> option so the calling program can handshake "
"with\n"
" this process and get its process id.\n"
"\n"
"EXAMPLE\n"
" darwin-debug --arch=i386 -- /bin/ls -al /tmp\n");
exit(1);
}
static void exit_with_errno(int err, const char *prefix) {
if (err) {
fprintf(stderr, "%s%s", prefix ? prefix : "", strerror(err));
exit(err);
}
}
pid_t posix_spawn_for_debug(char *const *argv, char *const *envp,
const char *working_dir, cpu_type_t cpu_type,
int disable_aslr) {
pid_t pid = 0;
const char *path = argv[0];
posix_spawnattr_t attr;
exit_with_errno(::posix_spawnattr_init(&attr),
"::posix_spawnattr_init (&attr) error: ");
// Here we are using a darwin specific feature that allows us to exec only
// since we want this program to turn into the program we want to debug,
// and also have the new program start suspended (right at __dyld_start)
// so we can debug it
short flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETEXEC |
POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
// Disable ASLR if we were asked to
if (disable_aslr)
flags |= _POSIX_SPAWN_DISABLE_ASLR;
sigset_t no_signals;
sigset_t all_signals;
sigemptyset(&no_signals);
sigfillset(&all_signals);
::posix_spawnattr_setsigmask(&attr, &no_signals);
::posix_spawnattr_setsigdefault(&attr, &all_signals);
// Set the flags we just made into our posix spawn attributes
exit_with_errno(::posix_spawnattr_setflags(&attr, flags),
"::posix_spawnattr_setflags (&attr, flags) error: ");
// Another darwin specific thing here where we can select the architecture
// of the binary we want to re-exec as.
if (cpu_type != 0) {
size_t ocount = 0;
exit_with_errno(
::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount),
"posix_spawnattr_setbinpref_np () error: ");
}
// I wish there was a posix_spawn flag to change the working directory of
// the inferior process we will spawn, but there currently isn't. If there
// ever is a better way to do this, we should use it. I would rather not
// manually fork, chdir in the child process, and then posix_spawn with exec
// as the whole reason for doing posix_spawn is to not hose anything up
// after the fork and prior to the exec...
if (working_dir)
::chdir(working_dir);
exit_with_errno(::posix_spawnp(&pid, path, NULL, &attr, (char *const *)argv,
(char *const *)envp),
"posix_spawn() error: ");
// This code will only be reached if the posix_spawn exec failed...
::posix_spawnattr_destroy(&attr);
return pid;
}
int main(int argc, char *const *argv, char *const *envp, const char **apple) {
#if defined(DEBUG_LLDB_LAUNCHER)
const char *program_name = strrchr(apple[0], '/');
if (program_name)
program_name++; // Skip the last slash..
else
program_name = apple[0];
printf("%s called with:\n", program_name);
for (int i = 0; i < argc; ++i)
printf("argv[%u] = '%s'\n", i, argv[i]);
#endif
cpu_type_t cpu_type = 0;
bool show_usage = false;
int ch;
int disable_aslr = 0; // By default we disable ASLR
bool pass_env = true;
std::string unix_socket_name;
std::string working_dir;
#if __GLIBC__
optind = 0;
#else
optreset = 1;
optind = 1;
#endif
while ((ch = getopt_long_only(argc, argv, "a:deE:hsu:?", g_long_options,
NULL)) != -1) {
switch (ch) {
case 0:
break;
case 'a': // "-a i386" or "--arch=i386"
if (optarg) {
if (streq(optarg, "i386"))
cpu_type = CPU_TYPE_I386;
else if (streq(optarg, "x86_64"))
cpu_type = CPU_TYPE_X86_64;
else if (streq(optarg, "x86_64h"))
cpu_type = 0; // Don't set CPU type when we have x86_64h
else if (strstr(optarg, "arm") == optarg)
cpu_type = CPU_TYPE_ARM;
else {
::fprintf(stderr, "error: unsupported cpu type '%s'\n", optarg);
::exit(1);
}
}
break;
case 'd':
disable_aslr = 1;
break;
case 'e':
pass_env = false;
break;
case 'E': {
// Since we will exec this program into our new program, we can just set
// environment
// variables in this process and they will make it into the child process.
std::string name;
std::string value;
const char *equal_pos = strchr(optarg, '=');
if (equal_pos) {
name.assign(optarg, equal_pos - optarg);
value.assign(equal_pos + 1);
} else {
name = optarg;
}
::setenv(name.c_str(), value.c_str(), 1);
} break;
case 's':
// Create a new session to avoid having control-C presses kill our current
// terminal session when this program is launched from a .command file
::setsid();
break;
case 'u':
unix_socket_name.assign(optarg);
break;
case 'w': {
struct stat working_dir_stat;
if (stat(optarg, &working_dir_stat) == 0)
working_dir.assign(optarg);
else
::fprintf(stderr, "warning: working directory doesn't exist: '%s'\n",
optarg);
} break;
case 'h':
case '?':
default:
show_usage = true;
break;
}
}
argc -= optind;
argv += optind;
if (show_usage || argc <= 0 || unix_socket_name.empty())
usage();
#if defined(DEBUG_LLDB_LAUNCHER)
printf("\n%s post options:\n", program_name);
for (int i = 0; i < argc; ++i)
printf("argv[%u] = '%s'\n", i, argv[i]);
#endif
// Open the socket that was passed in as an option
struct sockaddr_un saddr_un;
int s = ::socket(AF_UNIX, SOCK_STREAM, 0);
if (s < 0) {
perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
exit(1);
}
saddr_un.sun_family = AF_UNIX;
::strncpy(saddr_un.sun_path, unix_socket_name.c_str(),
sizeof(saddr_un.sun_path) - 1);
saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
saddr_un.sun_len = SUN_LEN(&saddr_un);
if (::connect(s, (struct sockaddr *)&saddr_un, SUN_LEN(&saddr_un)) < 0) {
perror("error: connect (socket, &saddr_un, saddr_un_len)");
exit(1);
}
// We were able to connect to the socket, now write our PID so whomever
// launched us will know this process's ID
char pid_str[64];
const int pid_str_len =
::snprintf(pid_str, sizeof(pid_str), "%i", ::getpid());
const int bytes_sent = ::send(s, pid_str, pid_str_len, 0);
if (pid_str_len != bytes_sent) {
perror("error: send (s, pid_str, pid_str_len, 0)");
exit(1);
}
// We are done with the socket
close(s);
system("clear");
printf("Launching: '%s'\n", argv[0]);
if (working_dir.empty()) {
char cwd[PATH_MAX];
const char *cwd_ptr = getcwd(cwd, sizeof(cwd));
printf("Working directory: '%s'\n", cwd_ptr);
} else {
printf("Working directory: '%s'\n", working_dir.c_str());
}
printf("%i arguments:\n", argc);
for (int i = 0; i < argc; ++i)
printf("argv[%u] = '%s'\n", i, argv[i]);
// Now we posix spawn to exec this process into the inferior that we want
// to debug.
posix_spawn_for_debug(
argv,
pass_env ? *_NSGetEnviron() : NULL, // Pass current environment as we may
// have modified it if "--env" options
// was used, do NOT pass "envp" here
working_dir.empty() ? NULL : working_dir.c_str(), cpu_type, disable_aslr);
return 0;
}
#endif // #if defined (__APPLE__)
Reference in New Issue View Git Blame Copy Permalink