2
/*--------------------------------------------------------------------*/
3
/*--- Launching valgrind m_launcher.c ---*/
4
/*--------------------------------------------------------------------*/
7
This file is part of Valgrind, a dynamic binary instrumentation
10
Copyright (C) 2000-2007 Julian Seward
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.
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.
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
28
The GNU General Public License is contained in the file COPYING.
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. */
48
#include "pub_core_debuglog.h"
49
#include "pub_core_vki.h" // Avoids warnings from
50
// pub_core_libcfile.h
51
#include "pub_core_libcproc.h" // For VALGRIND_LIB, VALGRIND_LAUNCHER
52
#include "pub_core_ume.h"
56
#define PATH_MAX 4096 /* POSIX refers to this a lot but I dunno
57
where it is defined */
60
#define EM_X86_64 62 // elf.h doesn't define this on some older systems
63
/* Report fatal errors */
64
__attribute__((noreturn))
65
static void barf ( const char *format, ... )
69
va_start(vargs, format);
70
fprintf(stderr, "valgrind: Cannot continue: ");
71
vfprintf(stderr, format, vargs);
72
fprintf(stderr, "\n");
80
/* Search the path for the client program */
81
static const char *find_client(const char *clientname)
83
static char fullname[PATH_MAX];
84
const char *path = getenv("PATH");
89
if ((colon = strchr(path, ':')) == NULL)
91
strcpy(fullname, path);
96
memcpy(fullname, path, colon - path);
97
fullname[colon - path] = '\0';
101
strcat(fullname, "/");
102
strcat(fullname, clientname);
104
if (access(fullname, R_OK|X_OK) == 0)
111
/* Examine the client and work out which platform it is for */
112
static const char *select_platform(const char *clientname)
115
unsigned char *header;
116
const char *platform = NULL;
117
long pagesize = sysconf(_SC_PAGESIZE);
119
if (strchr(clientname, '/') == NULL)
120
clientname = find_client(clientname);
122
if ((fd = open(clientname, O_RDONLY)) < 0)
124
// barf("open(%s): %s", clientname, strerror(errno));
126
if ((header = mmap(NULL, pagesize, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0)) == MAP_FAILED)
128
// barf("mmap(%s): %s", clientname, strerror(errno));
132
if (header[0] == '#' && header[1] == '!') {
133
char *interp = (char *)header + 2;
136
while (*interp == ' ' || *interp == '\t')
139
for (interpend = interp; !isspace(*interpend); interpend++)
144
platform = select_platform(interp);
145
} else if (memcmp(header, ELFMAG, SELFMAG) == 0) {
147
if (header[EI_CLASS] == ELFCLASS32) {
148
const Elf32_Ehdr *ehdr = (Elf32_Ehdr *)header;
150
if (header[EI_DATA] == ELFDATA2LSB) {
151
if (ehdr->e_machine == EM_386 &&
152
ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV) {
153
platform = "x86-linux";
156
else if (header[EI_DATA] == ELFDATA2MSB) {
157
if (ehdr->e_machine == EM_PPC &&
158
ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV) {
159
platform = "ppc32-linux";
162
} else if (header[EI_CLASS] == ELFCLASS64) {
163
const Elf64_Ehdr *ehdr = (Elf64_Ehdr *)header;
165
if (header[EI_DATA] == ELFDATA2LSB) {
166
if (ehdr->e_machine == EM_X86_64 &&
167
ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV) {
168
platform = "amd64-linux";
170
} else if (header[EI_DATA] == ELFDATA2MSB) {
171
if (ehdr->e_machine == EM_PPC64 &&
172
ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV) {
173
platform = "ppc64-linux";
179
munmap(header, pagesize);
184
/* Where we expect to find all our aux files */
185
static const char *valgrind_lib = VG_LIBDIR;
187
int main(int argc, char** argv, char** envp)
189
int i, j, loglevel, r;
190
const char *toolname = NULL;
191
const char *clientname = NULL;
192
const char *platform;
193
const char *default_platform;
196
char launcher_name[PATH_MAX+1];
200
/* Start the debugging-log system ASAP. First find out how many
201
"-d"s were specified. This is a pre-scan of the command line.
202
At the same time, look for the tool name. */
204
for (i = 1; i < argc; i++) {
205
if (argv[i][0] != '-') {
206
clientname = argv[i];
209
if (0 == strcmp(argv[i], "--")) {
211
clientname = argv[i+1];
214
if (0 == strcmp(argv[i], "-d"))
216
if (0 == strncmp(argv[i], "--tool=", 7))
217
toolname = argv[i] + 7;
220
/* ... and start the debug logger. Now we can safely emit logging
221
messages all through startup. */
222
VG_(debugLog_startup)(loglevel, "Stage 1");
224
/* Make sure we know which tool we're using */
226
VG_(debugLog)(1, "launcher", "tool '%s' requested\n", toolname);
228
VG_(debugLog)(1, "launcher",
229
"no tool requested, defaulting to 'memcheck'\n");
230
toolname = "memcheck";
233
/* Select a platform to use if we can't decide that by looking at
234
the executable (eg because it's a shell script). Note that the
235
default_platform is not necessarily either the primary or
236
secondary build target. Instead it's chosen to maximise the
237
chances that /bin/sh will work on it. Hence for a primary
238
target of ppc64-linux we still choose ppc32-linux as the default
239
target, because on most ppc64-linux setups, the basic /bin,
240
/usr/bin, etc, stuff is built in 32-bit mode, not 64-bit
242
if (0==strcmp(VG_PLATFORM,"x86-linux"))
243
default_platform = "x86-linux";
244
else if (0==strcmp(VG_PLATFORM,"amd64-linux"))
245
default_platform = "amd64-linux";
246
else if (0==strcmp(VG_PLATFORM,"ppc32-linux"))
247
default_platform = "ppc32-linux";
248
else if (0==strcmp(VG_PLATFORM,"ppc64-linux"))
249
default_platform = "ppc32-linux";
251
barf("Unknown VG_PLATFORM '%s'", VG_PLATFORM);
253
/* Work out what platform to use, or use the default platform if
255
if (clientname == NULL) {
256
VG_(debugLog)(1, "launcher",
257
"no client specified, defaulting platform to '%s'\n",
259
platform = default_platform;
260
} else if ((platform = select_platform(clientname)) != NULL) {
261
VG_(debugLog)(1, "launcher", "selected platform '%s'\n", platform);
263
VG_(debugLog)(1, "launcher",
264
"no platform detected, defaulting platform to '%s'\n",
266
platform = default_platform;
269
/* Figure out the name of this executable (viz, the launcher), so
270
we can tell stage2. stage2 will use the name for recursive
271
invokations of valgrind on child processes. */
272
memset(launcher_name, 0, PATH_MAX+1);
273
r = readlink("/proc/self/exe", launcher_name, PATH_MAX);
275
/* If /proc/self/exe can't be followed, don't give up. Instead
276
continue with an empty string for VALGRIND_LAUNCHER. In the
277
sys_execve wrapper, this is tested, and if found to be empty,
279
fprintf(stderr, "valgrind: warning (non-fatal): "
280
"readlink(\"/proc/self/exe\") failed.\n");
281
fprintf(stderr, "valgrind: continuing, however --trace-children=yes "
285
/* tediously augment the env: VALGRIND_LAUNCHER=launcher_name */
286
new_line = malloc(strlen(VALGRIND_LAUNCHER) + 1
287
+ strlen(launcher_name) + 1);
288
if (new_line == NULL)
289
barf("malloc of new_line failed.");
290
strcpy(new_line, VALGRIND_LAUNCHER);
291
strcat(new_line, "=");
292
strcat(new_line, launcher_name);
294
for (j = 0; envp[j]; j++)
296
new_env = malloc((j+2) * sizeof(char*));
298
barf("malloc of new_env failed.");
299
for (i = 0; i < j; i++)
300
new_env[i] = envp[i];
301
new_env[i++] = new_line;
305
/* Establish the correct VALGRIND_LIB. */
306
cp = getenv(VALGRIND_LIB);
311
/* Build the stage2 invokation, and execve it. Bye! */
312
toolfile = malloc(strlen(valgrind_lib) + strlen(toolname) + strlen(platform) + 3);
313
if (toolfile == NULL)
314
barf("malloc of toolfile failed.");
315
sprintf(toolfile, "%s/%s/%s", valgrind_lib, platform, toolname);
317
VG_(debugLog)(1, "launcher", "launching %s\n", toolfile);
319
execve(toolfile, argv, new_env);
321
fprintf(stderr, "valgrind: failed to start tool '%s' for platform '%s': %s\n",
322
toolname, platform, strerror(errno));