1 /* -*- mode: C; c-basic-offset: 3; -*- */
2
3 /*--------------------------------------------------------------------*/
4 /*--- Launching valgrind m_launcher.c ---*/
5 /*--------------------------------------------------------------------*/
6
7 /*
8 This file is part of Valgrind, a dynamic binary instrumentation
9 framework.
10
11 Copyright (C) 2000-2017 Julian Seward
12 jseward@acm.org
13
14 This program is free software; you can redistribute it and/or
15 modify it under the terms of the GNU General Public License as
16 published by the Free Software Foundation; either version 2 of the
17 License, or (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful, but
20 WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22 General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
27 02111-1307, USA.
28
29 The GNU General Public License is contained in the file COPYING.
30 */
31
32 /* Note: this is a "normal" program and not part of Valgrind proper,
33 and so it doesn't have to conform to Valgrind's arcane rules on
34 no-glibc-usage etc. */
35
36 /* Include valgrind headers before system headers to avoid problems
37 with the system headers #defining things which are used as names
38 of structure members in vki headers. */
39
40 #include "pub_core_debuglog.h"
41 #include "pub_core_vki.h" // Avoids warnings from
42 // pub_core_libcfile.h
43 #include "pub_core_libcproc.h" // For VALGRIND_LIB, VALGRIND_LAUNCHER
44 #include "pub_core_ume.h"
45
46 #include <assert.h>
47 #include <ctype.h>
48 #include <elf.h>
49 #include <errno.h>
50 #include <fcntl.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <unistd.h>
55
56 #ifndef EM_X86_64
57 #define EM_X86_64 62 // elf.h doesn't define this on some older systems
58 #endif
59
60 #ifndef EM_AARCH64
61 #define EM_AARCH64 183 // ditto
62 #endif
63
64 #ifndef EM_PPC64
65 #define EM_PPC64 21 // ditto
66 #endif
67
68 /* Report fatal errors */
69 __attribute__((noreturn))
barf(const char * format,...)70 static void barf ( const char *format, ... )
71 {
72 va_list vargs;
73
74 va_start(vargs, format);
75 fprintf(stderr, "valgrind: Cannot continue: ");
76 vfprintf(stderr, format, vargs);
77 fprintf(stderr, "\n");
78 va_end(vargs);
79
80 exit(1);
81 /*NOTREACHED*/
82 assert(0);
83 }
84
85 /* Search the path for the client program */
find_client(const char * clientname)86 static const char *find_client(const char *clientname)
87 {
88 char *fullname;
89 const char *path = getenv("PATH");
90 const char *colon;
91
92 assert(clientname != NULL);
93
94 if (path == NULL) return clientname;
95
96 /* Make the size of the FULLNAME buffer large enough. */
97 unsigned need = strlen(path) + strlen("/") + strlen(clientname) + 1;
98
99 fullname = malloc(need);
100 if (fullname == NULL)
101 barf("malloc of fullname failed.");
102
103 while (path)
104 {
105 if ((colon = strchr(path, ':')) == NULL)
106 {
107 strcpy(fullname, path);
108 path = NULL;
109 }
110 else
111 {
112 strncpy(fullname, path, colon - path);
113 fullname[colon - path] = '\0';
114 path = colon + 1;
115 }
116
117 strcat(fullname, "/");
118 strcat(fullname, clientname);
119
120 if (access(fullname, R_OK|X_OK) == 0)
121 return fullname;
122 }
123 free(fullname);
124
125 return clientname;
126 }
127
128 /* Examine the client and work out which platform it is for */
select_platform(const char * clientname)129 static const char *select_platform(const char *clientname)
130 {
131 int fd;
132 union {
133 char c[4096];
134 Elf32_Ehdr ehdr32;
135 Elf64_Ehdr ehdr64;
136 } header;
137 ssize_t n_bytes;
138 const char *platform = NULL;
139
140 VG_(debugLog)(2, "launcher", "selecting platform for '%s'\n", clientname);
141
142 if (strchr(clientname, '/') == NULL)
143 clientname = find_client(clientname);
144
145 VG_(debugLog)(2, "launcher", "selecting platform for '%s'\n", clientname);
146
147 if ((fd = open(clientname, O_RDONLY)) < 0)
148 return NULL;
149 // barf("open(%s): %s", clientname, strerror(errno));
150
151 VG_(debugLog)(2, "launcher", "opened '%s'\n", clientname);
152
153 n_bytes = read(fd, header.c, sizeof(header));
154 close(fd);
155 if (n_bytes < 2) {
156 return NULL;
157 }
158
159 VG_(debugLog)(2, "launcher", "read %ld bytes from '%s'\n",
160 (long int)n_bytes, clientname);
161
162 if (header.c[0] == '#' && header.c[1] == '!') {
163 int i = 2;
164
165 STATIC_ASSERT(VKI_BINPRM_BUF_SIZE < sizeof header);
166 if (n_bytes > VKI_BINPRM_BUF_SIZE)
167 n_bytes = VKI_BINPRM_BUF_SIZE - 1;
168 header.c[n_bytes] = '\0';
169 char *eol = strchr(header.c, '\n');
170 if (eol != NULL)
171 *eol = '\0';
172
173 // Skip whitespace.
174 while (header.c[i] == ' '|| header.c[i] == '\t')
175 i++;
176
177 // Get the interpreter name.
178 const char *interp = header.c + i;
179
180 if (header.c[i] == '\0') {
181 // No interpreter was found; fall back to default shell
182 # if defined(VGPV_arm_linux_android) \
183 || defined(VGPV_x86_linux_android) \
184 || defined(VGPV_mips32_linux_android) \
185 || defined(VGPV_arm64_linux_android)
186 interp = "/system/bin/sh";
187 # else
188 interp = "/bin/sh";
189 # endif
190 } else {
191 while (header.c[i]) {
192 if (header.c[i] == ' ' || header.c[i] == '\t') break;
193 i++;
194 }
195 header.c[i] = '\0';
196 }
197
198 platform = select_platform(interp);
199
200 } else if (n_bytes >= SELFMAG && memcmp(header.c, ELFMAG, SELFMAG) == 0) {
201
202 if (n_bytes >= sizeof(Elf32_Ehdr) && header.c[EI_CLASS] == ELFCLASS32) {
203
204 if (header.c[EI_DATA] == ELFDATA2LSB) {
205 # if defined(VGO_solaris)
206 if (header.ehdr32.e_machine == EM_386 &&
207 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
208 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)) {
209 platform = "x86-solaris";
210 }
211 else
212 # endif
213 if (header.ehdr32.e_machine == EM_386 &&
214 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
215 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
216 platform = "x86-linux";
217 }
218 else
219 if (header.ehdr32.e_machine == EM_ARM &&
220 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
221 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
222 platform = "arm-linux";
223 }
224 else
225 if (header.ehdr32.e_machine == EM_MIPS &&
226 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
227 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
228 platform = "mips32-linux";
229 }
230 }
231 else if (header.c[EI_DATA] == ELFDATA2MSB) {
232 if (header.ehdr32.e_machine == EM_PPC &&
233 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
234 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
235 platform = "ppc32-linux";
236 }
237 else
238 if (header.ehdr32.e_machine == EM_MIPS &&
239 (header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
240 header.ehdr32.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
241 platform = "mips32-linux";
242 }
243 }
244
245 } else if (n_bytes >= sizeof(Elf64_Ehdr) && header.c[EI_CLASS] == ELFCLASS64) {
246
247 if (header.c[EI_DATA] == ELFDATA2LSB) {
248 # if defined(VGO_solaris)
249 if (header.ehdr64.e_machine == EM_X86_64 &&
250 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
251 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)) {
252 platform = "amd64-solaris";
253 }
254 else
255 # endif
256 if (header.ehdr64.e_machine == EM_X86_64 &&
257 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
258 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
259 platform = "amd64-linux";
260 } else if (header.ehdr64.e_machine == EM_MIPS &&
261 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
262 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
263 platform = "mips64-linux";
264 } else if (header.ehdr64.e_machine == EM_AARCH64 &&
265 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
266 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
267 platform = "arm64-linux";
268 } else if (header.ehdr64.e_machine == EM_PPC64 &&
269 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
270 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
271 platform = "ppc64le-linux";
272 }
273 } else if (header.c[EI_DATA] == ELFDATA2MSB) {
274 # if !defined(VGPV_arm_linux_android) \
275 && !defined(VGPV_x86_linux_android) \
276 && !defined(VGPV_mips32_linux_android) \
277 && !defined(VGPV_arm64_linux_android)
278 if (header.ehdr64.e_machine == EM_PPC64 &&
279 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
280 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
281 platform = "ppc64be-linux";
282 }
283 else
284 if (header.ehdr64.e_machine == EM_S390 &&
285 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
286 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
287 platform = "s390x-linux";
288 } else if (header.ehdr64.e_machine == EM_MIPS &&
289 (header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_SYSV ||
290 header.ehdr64.e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
291 platform = "mips64-linux";
292 }
293 # endif
294 }
295 }
296 }
297
298 VG_(debugLog)(2, "launcher", "selected platform '%s'\n",
299 platform ? platform : "unknown");
300
301 return platform;
302 }
303
304 /* Where we expect to find all our aux files */
305 static const char *valgrind_lib = VG_LIBDIR;
306
main(int argc,char ** argv,char ** envp)307 int main(int argc, char** argv, char** envp)
308 {
309 int i, j, loglevel, r;
310 const char *toolname = NULL;
311 const char *clientname = NULL;
312 const char *platform;
313 const char *default_platform;
314 const char *cp;
315 const char *linkname;
316 char *toolfile;
317 const char *launcher_name;
318 char* new_line;
319 char** new_env;
320
321 /* Start the debugging-log system ASAP. First find out how many
322 "-d"s were specified. This is a pre-scan of the command line.
323 At the same time, look for the tool name. */
324 loglevel = 0;
325 for (i = 1; i < argc; i++) {
326 if (argv[i][0] != '-') {
327 clientname = argv[i];
328 break;
329 }
330 if (0 == strcmp(argv[i], "--")) {
331 if (i+1 < argc)
332 clientname = argv[i+1];
333 break;
334 }
335 if (0 == strcmp(argv[i], "-d"))
336 loglevel++;
337 if (0 == strncmp(argv[i], "--tool=", 7))
338 toolname = argv[i] + 7;
339 }
340
341 /* ... and start the debug logger. Now we can safely emit logging
342 messages all through startup. */
343 VG_(debugLog_startup)(loglevel, "Stage 1");
344
345 /* Make sure we know which tool we're using */
346 if (toolname) {
347 VG_(debugLog)(1, "launcher", "tool '%s' requested\n", toolname);
348 } else {
349 VG_(debugLog)(1, "launcher",
350 "no tool requested, defaulting to 'memcheck'\n");
351 toolname = "memcheck";
352 }
353
354 /* Select a platform to use if we can't decide that by looking at
355 the executable (eg because it's a shell script). VG_PLATFORM is the
356 default_platform. Its value is defined in coregrind/Makefile.am and
357 typically it is the primary build target. Unless the primary build
358 target is not built is not built in which case VG_PLATFORM is the
359 secondary build target. */
360 # if defined(VGO_linux)
361 if ((0==strcmp(VG_PLATFORM,"x86-linux")) ||
362 (0==strcmp(VG_PLATFORM,"amd64-linux")) ||
363 (0==strcmp(VG_PLATFORM,"ppc32-linux")) ||
364 (0==strcmp(VG_PLATFORM,"ppc64be-linux")) ||
365 (0==strcmp(VG_PLATFORM,"ppc64le-linux")) ||
366 (0==strcmp(VG_PLATFORM,"arm-linux")) ||
367 (0==strcmp(VG_PLATFORM,"arm64-linux")) ||
368 (0==strcmp(VG_PLATFORM,"s390x-linux")) ||
369 (0==strcmp(VG_PLATFORM,"mips32-linux")) ||
370 (0==strcmp(VG_PLATFORM,"mips64-linux")))
371 default_platform = VG_PLATFORM;
372 # elif defined(VGO_solaris)
373 if ((0==strcmp(VG_PLATFORM,"x86-solaris")) ||
374 (0==strcmp(VG_PLATFORM,"amd64-solaris")))
375 default_platform = SOLARIS_LAUNCHER_DEFAULT_PLATFORM;
376 # else
377 # error Unknown OS
378 # endif
379 else
380 barf("Unknown VG_PLATFORM '%s'", VG_PLATFORM);
381
382 /* Work out what platform to use, or use the default platform if
383 not possible. */
384 if (clientname == NULL) {
385 VG_(debugLog)(1, "launcher",
386 "no client specified, defaulting platform to '%s'\n",
387 default_platform);
388 platform = default_platform;
389 } else if ((platform = select_platform(clientname)) != NULL) {
390 VG_(debugLog)(1, "launcher", "selected platform '%s'\n", platform);
391 } else {
392 VG_(debugLog)(1, "launcher",
393 "no platform detected, defaulting platform to '%s'\n",
394 default_platform);
395 platform = default_platform;
396 }
397
398 /* Figure out the name of this executable (viz, the launcher), so
399 we can tell stage2. stage2 will use the name for recursive
400 invocations of valgrind on child processes. */
401 # if defined(VGO_linux)
402 linkname = "/proc/self/exe";
403 # elif defined(VGO_solaris)
404 linkname = "/proc/self/path/a.out";
405 # else
406 # error Unknown OS
407 # endif
408 unsigned bufsiz = 0;
409 char *buf = NULL;
410
411 while (42) {
412 bufsiz += 500;
413 buf = realloc(buf, bufsiz);
414 if (buf == NULL)
415 barf("realloc of buf failed.");
416 r = readlink(linkname, buf, bufsiz);
417 if (r == -1) {
418 /* If /proc/self/exe (/proc/self/path/a.out) can't be followed, don't
419 give up. Instead continue with an empty string for VALGRIND_LAUNCHER.
420 In the sys_execve wrapper, this is tested, and if found to be empty,
421 fail the execve. */
422 fprintf(stderr, "valgrind: warning (non-fatal): "
423 "readlink(\"%s\") failed.\n", linkname);
424 fprintf(stderr, "valgrind: continuing, however --trace-children=yes "
425 "will not work.\n");
426 launcher_name = "";
427 break;
428 }
429 if (r == bufsiz) continue; // buffer to small; retry
430
431 assert(r < bufsiz); // paranoia
432
433 buf[r] = '\0';
434 launcher_name = buf;
435 break;
436 }
437
438 /* tediously augment the env: VALGRIND_LAUNCHER=launcher_name */
439 new_line = malloc(strlen(VALGRIND_LAUNCHER) + 1
440 + strlen(launcher_name) + 1);
441 if (new_line == NULL)
442 barf("malloc of new_line failed.");
443 strcpy(new_line, VALGRIND_LAUNCHER);
444 strcat(new_line, "=");
445 strcat(new_line, launcher_name);
446
447 for (j = 0; envp[j]; j++)
448 ;
449 new_env = malloc((j+2) * sizeof(char*));
450 if (new_env == NULL)
451 barf("malloc of new_env failed.");
452 for (i = 0; i < j; i++)
453 new_env[i] = envp[i];
454 new_env[i++] = new_line;
455 new_env[i++] = NULL;
456 assert(i == j+2);
457
458 /* Establish the correct VALGRIND_LIB. */
459 cp = getenv(VALGRIND_LIB);
460
461 if (cp != NULL)
462 valgrind_lib = cp;
463
464 /* Build the stage2 invocation, and execve it. Bye! */
465 toolfile = malloc(strlen(valgrind_lib) + strlen(toolname) + strlen(platform) + 3);
466 if (toolfile == NULL)
467 barf("malloc of toolfile failed.");
468 sprintf(toolfile, "%s/%s-%s", valgrind_lib, toolname, platform);
469
470 VG_(debugLog)(1, "launcher", "launching %s\n", toolfile);
471
472 execve(toolfile, argv, new_env);
473
474 fprintf(stderr, "valgrind: failed to start tool '%s' for platform '%s': %s\n",
475 toolname, platform, strerror(errno));
476
477 exit(1);
478 }
479