lldb/tools/darwin-debug/darwin-debug.cpp

   1 //===-- darwin-debug.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 // Darwin launch helper
  10 //
  11 // This program was written to allow programs to be launched in a new
  12 // Terminal.app window and have the application be stopped for debugging
  13 // at the program entry point.
  14 //
  15 // Although it uses posix_spawn(), it uses Darwin specific posix spawn
  16 // attribute flags to accomplish its task. It uses an "exec only" flag
  17 // which avoids forking this process, and it uses a "stop at entry"
  18 // flag to stop the program at the entry point.
  19 //
  20 // Since it uses darwin specific flags this code should not be compiled
  21 // on other systems.
  22 #if defined(__APPLE__)
  23
  24 #include <climits>
  25 #include <crt_externs.h>
  26 #include <csignal>
  27 #include <cstdio>
  28 #include <cstdlib>
  29 #include <cstring>
  30 #include <getopt.h>
  31 #include <mach/machine.h>
  32 #include <spawn.h>
  33 #include <sys/socket.h>
  34 #include <sys/stat.h>
  35 #include <sys/types.h>
  36 #include <sys/un.h>
  37
  38 #include <string>
  39
  40 #ifndef _POSIX_SPAWN_DISABLE_ASLR
  41 #define _POSIX_SPAWN_DISABLE_ASLR 0x0100
  42 #endif
  43
  44 #define streq(a, b) strcmp(a, b) == 0
  45
  46 static struct option g_long_options[] = {
  47     {"arch", required_argument, NULL, 'a'},
  48     {"disable-aslr", no_argument, NULL, 'd'},
  49     {"no-env", no_argument, NULL, 'e'},
  50     {"help", no_argument, NULL, 'h'},
  51     {"setsid", no_argument, NULL, 's'},
  52     {"unix-socket", required_argument, NULL, 'u'},
  53     {"working-dir", required_argument, NULL, 'w'},
  54     {"env", required_argument, NULL, 'E'},
  55     {NULL, 0, NULL, 0}};
  56
  57 static void usage() {
  58   puts("NAME\n"
  59        "    darwin-debug -- posix spawn a process that is stopped at the entry "
  60        "point\n"
  61        "                    for debugging.\n"
  62        "\n"
  63        "SYNOPSIS\n"
  64        "    darwin-debug --unix-socket=<SOCKET> [--arch=<ARCH>] "
  65        "[--working-dir=<PATH>] [--disable-aslr] [--no-env] [--setsid] [--help] "
  66        "-- <PROGRAM> [<PROGRAM-ARG> <PROGRAM-ARG> ....]\n"
  67        "\n"
  68        "DESCRIPTION\n"
  69        "    darwin-debug will exec itself into a child process <PROGRAM> that "
  70        "is\n"
  71        "    halted for debugging. It does this by using posix_spawn() along "
  72        "with\n"
  73        "    darwin specific posix_spawn flags that allows exec only (no fork), "
  74        "and\n"
  75        "    stop at the program entry point. Any program arguments "
  76        "<PROGRAM-ARG> are\n"
  77        "    passed on to the exec as the arguments for the new process. The "
  78        "current\n"
  79        "    environment will be passed to the new process unless the "
  80        "\"--no-env\"\n"
  81        "    option is used. A unix socket must be supplied using the\n"
  82        "    --unix-socket=<SOCKET> option so the calling program can handshake "
  83        "with\n"
  84        "    this process and get its process id.\n"
  85        "\n"
  86        "EXAMPLE\n"
  87        "   darwin-debug --arch=i386 -- /bin/ls -al /tmp\n");
  88   exit(1);
  89 }
  90
  91 static void exit_with_errno(int err, const char *prefix) {
  92   if (err) {
  93     fprintf(stderr, "%s%s", prefix ? prefix : "", strerror(err));
  94     exit(err);
  95   }
  96 }
  97
  98 pid_t posix_spawn_for_debug(char *const *argv, char *const *envp,
  99                             const char *working_dir, cpu_type_t cpu_type,
 100                             int disable_aslr) {
 101   pid_t pid = 0;
 102
 103   const char *path = argv[0];
 104
 105   posix_spawnattr_t attr;
 106
 107   exit_with_errno(::posix_spawnattr_init(&attr),
 108                   "::posix_spawnattr_init (&attr) error: ");
 109
 110   // Here we are using a darwin specific feature that allows us to exec only
 111   // since we want this program to turn into the program we want to debug,
 112   // and also have the new program start suspended (right at __dyld_start)
 113   // so we can debug it
 114   short flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETEXEC |
 115                 POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
 116
 117   // Disable ASLR if we were asked to
 118   if (disable_aslr)
 119     flags |= _POSIX_SPAWN_DISABLE_ASLR;
 120
 121   sigset_t no_signals;
 122   sigset_t all_signals;
 123   sigemptyset(&no_signals);
 124   sigfillset(&all_signals);
 125   ::posix_spawnattr_setsigmask(&attr, &no_signals);
 126   ::posix_spawnattr_setsigdefault(&attr, &all_signals);
 127
 128   // Set the flags we just made into our posix spawn attributes
 129   exit_with_errno(::posix_spawnattr_setflags(&attr, flags),
 130                   "::posix_spawnattr_setflags (&attr, flags) error: ");
 131
 132   // Another darwin specific thing here where we can select the architecture
 133   // of the binary we want to re-exec as.
 134   if (cpu_type != 0) {
 135     size_t ocount = 0;
 136     exit_with_errno(
 137         ::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount),
 138         "posix_spawnattr_setbinpref_np () error: ");
 139   }
 140
 141   // I wish there was a posix_spawn flag to change the working directory of
 142   // the inferior process we will spawn, but there currently isn't. If there
 143   // ever is a better way to do this, we should use it. I would rather not
 144   // manually fork, chdir in the child process, and then posix_spawn with exec
 145   // as the whole reason for doing posix_spawn is to not hose anything up
 146   // after the fork and prior to the exec...
 147   if (working_dir)
 148     ::chdir(working_dir);
 149
 150   exit_with_errno(::posix_spawnp(&pid, path, NULL, &attr, (char *const *)argv,
 151                                  (char *const *)envp),
 152                   "posix_spawn() error: ");
 153
 154   // This code will only be reached if the posix_spawn exec failed...
 155   ::posix_spawnattr_destroy(&attr);
 156
 157   return pid;
 158 }
 159
 160 int main(int argc, char *const *argv, char *const *envp, const char **apple) {
 161 #if defined(DEBUG_LLDB_LAUNCHER)
 162   const char *program_name = strrchr(apple[0], '/');
 163
 164   if (program_name)
 165     program_name++; // Skip the last slash..
 166   else
 167     program_name = apple[0];
 168
 169   printf("%s called with:\n", program_name);
 170   for (int i = 0; i < argc; ++i)
 171     printf("argv[%u] = '%s'\n", i, argv[i]);
 172 #endif
 173
 174   cpu_type_t cpu_type = 0;
 175   bool show_usage = false;
 176   int ch;
 177   int disable_aslr = 0; // By default we disable ASLR
 178   bool pass_env = true;
 179   std::string unix_socket_name;
 180   std::string working_dir;
 181
 182 #if __GLIBC__
 183   optind = 0;
 184 #else
 185   optreset = 1;
 186   optind = 1;
 187 #endif
 188
 189   while ((ch = getopt_long_only(argc, argv, "a:deE:hsu:?", g_long_options,
 190                                 NULL)) != -1) {
 191     switch (ch) {
 192     case 0:
 193       break;
 194
 195     case 'a': // "-a i386" or "--arch=i386"
 196       if (optarg) {
 197         if (streq(optarg, "i386"))
 198           cpu_type = CPU_TYPE_I386;
 199         else if (streq(optarg, "x86_64"))
 200           cpu_type = CPU_TYPE_X86_64;
 201         else if (streq(optarg, "x86_64h"))
 202           cpu_type = 0; // Don't set CPU type when we have x86_64h
 203         else if (strstr(optarg, "arm") == optarg)
 204           cpu_type = CPU_TYPE_ARM;
 205         else {
 206           ::fprintf(stderr, "error: unsupported cpu type '%s'\n", optarg);
 207           ::exit(1);
 208         }
 209       }
 210       break;
 211
 212     case 'd':
 213       disable_aslr = 1;
 214       break;
 215
 216     case 'e':
 217       pass_env = false;
 218       break;
 219
 220     case 'E': {
 221       // Since we will exec this program into our new program, we can just set
 222       // environment
 223       // variables in this process and they will make it into the child process.
 224       std::string name;
 225       std::string value;
 226       const char *equal_pos = strchr(optarg, '=');
 227       if (equal_pos) {
 228         name.assign(optarg, equal_pos - optarg);
 229         value.assign(equal_pos + 1);
 230       } else {
 231         name = optarg;
 232       }
 233       ::setenv(name.c_str(), value.c_str(), 1);
 234     } break;
 235
 236     case 's':
 237       // Create a new session to avoid having control-C presses kill our current
 238       // terminal session when this program is launched from a .command file
 239       ::setsid();
 240       break;
 241
 242     case 'u':
 243       unix_socket_name.assign(optarg);
 244       break;
 245
 246     case 'w': {
 247       struct stat working_dir_stat;
 248       if (stat(optarg, &working_dir_stat) == 0)
 249         working_dir.assign(optarg);
 250       else
 251         ::fprintf(stderr, "warning: working directory doesn't exist: '%s'\n",
 252                   optarg);
 253     } break;
 254
 255     case 'h':
 256     case '?':
 257     default:
 258       show_usage = true;
 259       break;
 260     }
 261   }
 262   argc -= optind;
 263   argv += optind;
 264
 265   if (show_usage || argc <= 0 || unix_socket_name.empty())
 266     usage();
 267
 268 #if defined(DEBUG_LLDB_LAUNCHER)
 269   printf("\n%s post options:\n", program_name);
 270   for (int i = 0; i < argc; ++i)
 271     printf("argv[%u] = '%s'\n", i, argv[i]);
 272 #endif
 273
 274   // Open the socket that was passed in as an option
 275   struct sockaddr_un saddr_un;
 276   int s = ::socket(AF_UNIX, SOCK_STREAM, 0);
 277   if (s < 0) {
 278     perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
 279     exit(1);
 280   }
 281
 282   saddr_un.sun_family = AF_UNIX;
 283   ::strncpy(saddr_un.sun_path, unix_socket_name.c_str(),
 284             sizeof(saddr_un.sun_path) - 1);
 285   saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
 286   saddr_un.sun_len = SUN_LEN(&saddr_un);
 287
 288   if (::connect(s, (struct sockaddr *)&saddr_un, SUN_LEN(&saddr_un)) < 0) {
 289     perror("error: connect (socket, &saddr_un, saddr_un_len)");
 290     exit(1);
 291   }
 292
 293   // We were able to connect to the socket, now write our PID so whomever
 294   // launched us will know this process's ID
 295   char pid_str[64];
 296   const int pid_str_len =
 297       ::snprintf(pid_str, sizeof(pid_str), "%i", ::getpid());
 298   const int bytes_sent = ::send(s, pid_str, pid_str_len, 0);
 299
 300   if (pid_str_len != bytes_sent) {
 301     perror("error: send (s, pid_str, pid_str_len, 0)");
 302     exit(1);
 303   }
 304
 305   // We are done with the socket
 306   close(s);
 307
 308   system("clear");
 309   printf("Launching: '%s'\n", argv[0]);
 310   if (working_dir.empty()) {
 311     char cwd[PATH_MAX];
 312     const char *cwd_ptr = getcwd(cwd, sizeof(cwd));
 313     printf("Working directory: '%s'\n", cwd_ptr);
 314   } else {
 315     printf("Working directory: '%s'\n", working_dir.c_str());
 316   }
 317   printf("%i arguments:\n", argc);
 318
 319   for (int i = 0; i < argc; ++i)
 320     printf("argv[%u] = '%s'\n", i, argv[i]);
 321
 322   // Now we posix spawn to exec this process into the inferior that we want
 323   // to debug.
 324   posix_spawn_for_debug(
 325       argv,
 326       pass_env ? *_NSGetEnviron() : NULL, // Pass current environment as we may
 327                                           // have modified it if "--env" options
 328                                           // was used, do NOT pass "envp" here
 329       working_dir.empty() ? NULL : working_dir.c_str(), cpu_type, disable_aslr);
 330
 331   return 0;
 332 }
 333
 334 #endif // #if defined (__APPLE__)