/Users/buildslave/jenkins/workspace/coverage/llvm-project/lldb/tools/darwin-debug/darwin-debug.cpp
Line | Count | Source (jump to first uncovered line) |
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 | 0 | #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 | 0 | static void usage() { |
58 | 0 | puts("NAME\n" |
59 | 0 | " darwin-debug -- posix spawn a process that is stopped at the entry " |
60 | 0 | "point\n" |
61 | 0 | " for debugging.\n" |
62 | 0 | "\n" |
63 | 0 | "SYNOPSIS\n" |
64 | 0 | " darwin-debug --unix-socket=<SOCKET> [--arch=<ARCH>] " |
65 | 0 | "[--working-dir=<PATH>] [--disable-aslr] [--no-env] [--setsid] [--help] " |
66 | 0 | "-- <PROGRAM> [<PROGRAM-ARG> <PROGRAM-ARG> ....]\n" |
67 | 0 | "\n" |
68 | 0 | "DESCRIPTION\n" |
69 | 0 | " darwin-debug will exec itself into a child process <PROGRAM> that " |
70 | 0 | "is\n" |
71 | 0 | " halted for debugging. It does this by using posix_spawn() along " |
72 | 0 | "with\n" |
73 | 0 | " darwin specific posix_spawn flags that allows exec only (no fork), " |
74 | 0 | "and\n" |
75 | 0 | " stop at the program entry point. Any program arguments " |
76 | 0 | "<PROGRAM-ARG> are\n" |
77 | 0 | " passed on to the exec as the arguments for the new process. The " |
78 | 0 | "current\n" |
79 | 0 | " environment will be passed to the new process unless the " |
80 | 0 | "\"--no-env\"\n" |
81 | 0 | " option is used. A unix socket must be supplied using the\n" |
82 | 0 | " --unix-socket=<SOCKET> option so the calling program can handshake " |
83 | 0 | "with\n" |
84 | 0 | " this process and get its process id.\n" |
85 | 0 | "\n" |
86 | 0 | "EXAMPLE\n" |
87 | 0 | " darwin-debug --arch=i386 -- /bin/ls -al /tmp\n"); |
88 | 0 | exit(1); |
89 | 0 | } |
90 | | |
91 | 0 | static void exit_with_errno(int err, const char *prefix) { |
92 | 0 | if (err) { |
93 | 0 | fprintf(stderr, "%s%s", prefix ? prefix : "", strerror(err)); |
94 | 0 | exit(err); |
95 | 0 | } |
96 | 0 | } |
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 | 0 | int disable_aslr) { |
101 | 0 | pid_t pid = 0; |
102 | |
|
103 | 0 | const char *path = argv[0]; |
104 | |
|
105 | 0 | posix_spawnattr_t attr; |
106 | |
|
107 | 0 | exit_with_errno(::posix_spawnattr_init(&attr), |
108 | 0 | "::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 | 0 | short flags = POSIX_SPAWN_START_SUSPENDED | POSIX_SPAWN_SETEXEC | |
115 | 0 | POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK; |
116 | | |
117 | | // Disable ASLR if we were asked to |
118 | 0 | if (disable_aslr) |
119 | 0 | flags |= _POSIX_SPAWN_DISABLE_ASLR; |
120 | |
|
121 | 0 | sigset_t no_signals; |
122 | 0 | sigset_t all_signals; |
123 | 0 | sigemptyset(&no_signals); |
124 | 0 | sigfillset(&all_signals); |
125 | 0 | ::posix_spawnattr_setsigmask(&attr, &no_signals); |
126 | 0 | ::posix_spawnattr_setsigdefault(&attr, &all_signals); |
127 | | |
128 | | // Set the flags we just made into our posix spawn attributes |
129 | 0 | exit_with_errno(::posix_spawnattr_setflags(&attr, flags), |
130 | 0 | "::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 | 0 | if (cpu_type != 0) { |
135 | 0 | size_t ocount = 0; |
136 | 0 | exit_with_errno( |
137 | 0 | ::posix_spawnattr_setbinpref_np(&attr, 1, &cpu_type, &ocount), |
138 | 0 | "posix_spawnattr_setbinpref_np () error: "); |
139 | 0 | } |
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 | 0 | if (working_dir) |
148 | 0 | ::chdir(working_dir); |
149 | |
|
150 | 0 | exit_with_errno(::posix_spawnp(&pid, path, NULL, &attr, (char *const *)argv, |
151 | 0 | (char *const *)envp), |
152 | 0 | "posix_spawn() error: "); |
153 | | |
154 | | // This code will only be reached if the posix_spawn exec failed... |
155 | 0 | ::posix_spawnattr_destroy(&attr); |
156 | |
|
157 | 0 | return pid; |
158 | 0 | } |
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__) |