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