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-2010 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 <stdarg.h>
51#include <stdio.h>
52#include <stdlib.h>
53#include <string.h>
54#include <sys/mman.h>
55#ifdef ANDROID
56#include <linux/user.h>
57#else
58#include <sys/user.h>
59#endif
60#include <unistd.h>
61
62
63
64#define PATH_MAX 4096 /* POSIX refers to this a lot but I dunno
65                         where it is defined */
66
67#ifndef EM_X86_64
68#define EM_X86_64 62    // elf.h doesn't define this on some older systems
69#endif
70#ifndef EM_PPC64
71#define EM_PPC64 21     // elf.h doesn't define this on Android
72#endif
73
74/* Report fatal errors */
75__attribute__((noreturn))
76static void barf ( const char *format, ... )
77{
78   va_list vargs;
79
80   va_start(vargs, format);
81   fprintf(stderr, "valgrind: Cannot continue: ");
82   vfprintf(stderr, format, vargs);
83   fprintf(stderr, "\n");
84   va_end(vargs);
85
86   exit(1);
87   /*NOTREACHED*/
88   assert(0);
89}
90
91/* Search the path for the client program */
92static const char *find_client(const char *clientname)
93{
94   static char fullname[PATH_MAX];
95   const char *path = getenv("PATH");
96   const char *colon;
97
98   while (path)
99   {
100      if ((colon = strchr(path, ':')) == NULL)
101      {
102         strcpy(fullname, path);
103         path = NULL;
104      }
105      else
106      {
107         memcpy(fullname, path, colon - path);
108         fullname[colon - path] = '\0';
109         path = colon + 1;
110      }
111
112      strcat(fullname, "/");
113      strcat(fullname, clientname);
114
115      if (access(fullname, R_OK|X_OK) == 0)
116         return fullname;
117   }
118
119   return clientname;
120}
121
122/* Examine the client and work out which platform it is for */
123static const char *select_platform(const char *clientname)
124{
125   int fd;
126   uint8_t header[4096];
127   ssize_t n_bytes;
128   const char *platform = NULL;
129
130   VG_(debugLog)(2, "launcher", "selecting platform for '%s'\n", clientname);
131
132   if (strchr(clientname, '/') == NULL)
133      clientname = find_client(clientname);
134
135   VG_(debugLog)(2, "launcher", "selecting platform for '%s'\n", clientname);
136
137   if ((fd = open(clientname, O_RDONLY)) < 0)
138      return NULL;
139   //   barf("open(%s): %s", clientname, strerror(errno));
140
141   VG_(debugLog)(2, "launcher", "opened '%s'\n", clientname);
142
143   n_bytes = read(fd, header, sizeof(header));
144   close(fd);
145   if (n_bytes < 2) {
146      return NULL;
147   }
148
149   VG_(debugLog)(2, "launcher", "read %ld bytes from '%s'\n",
150                    (long int)n_bytes, clientname);
151
152   if (header[0] == '#' && header[1] == '!') {
153      int i = 2;
154      char *interp = (char *)header + 2;
155
156      // Skip whitespace.
157      while (1) {
158         if (i == n_bytes) return NULL;
159         if (' ' != header[i] && '\t' != header[i]) break;
160         i++;
161      }
162
163      // Get the interpreter name.
164      interp = &header[i];
165      while (1) {
166         if (i == n_bytes) break;
167         if (isspace(header[i])) break;
168         i++;
169      }
170      if (i == n_bytes) return NULL;
171      header[i] = '\0';
172
173      platform = select_platform(interp);
174
175   } else if (n_bytes >= SELFMAG && memcmp(header, ELFMAG, SELFMAG) == 0) {
176
177      if (n_bytes >= sizeof(Elf32_Ehdr) && header[EI_CLASS] == ELFCLASS32) {
178         const Elf32_Ehdr *ehdr = (Elf32_Ehdr *)header;
179
180         if (header[EI_DATA] == ELFDATA2LSB) {
181            if (ehdr->e_machine == EM_386 &&
182                (ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV ||
183                 ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
184               platform = "x86-linux";
185            }
186            else
187            if (ehdr->e_machine == EM_ARM &&
188                (ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV ||
189                 ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
190               platform = "arm-linux";
191            }
192         }
193         else if (header[EI_DATA] == ELFDATA2MSB) {
194            if (ehdr->e_machine == EM_PPC &&
195                (ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV ||
196                 ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
197               platform = "ppc32-linux";
198            }
199         }
200
201      } else if (n_bytes >= sizeof(Elf64_Ehdr) && header[EI_CLASS] == ELFCLASS64) {
202         const Elf64_Ehdr *ehdr = (Elf64_Ehdr *)header;
203
204         if (header[EI_DATA] == ELFDATA2LSB) {
205            if (ehdr->e_machine == EM_X86_64 &&
206                (ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV ||
207                 ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
208               platform = "amd64-linux";
209            }
210         } else if (header[EI_DATA] == ELFDATA2MSB) {
211            if (ehdr->e_machine == EM_PPC64 &&
212                (ehdr->e_ident[EI_OSABI] == ELFOSABI_SYSV ||
213                 ehdr->e_ident[EI_OSABI] == ELFOSABI_LINUX)) {
214               platform = "ppc64-linux";
215            }
216         }
217      }
218   }
219
220   VG_(debugLog)(2, "launcher", "selected platform '%s'\n",
221                 platform ? platform : "unknown");
222
223   return platform;
224}
225
226/* Where we expect to find all our aux files */
227static const char *valgrind_lib = VG_LIBDIR;
228
229int main(int argc, char** argv, char** envp)
230{
231   int i, j, loglevel, r;
232   const char *toolname = NULL;
233   const char *clientname = NULL;
234   const char *platform;
235   const char *default_platform;
236   const char *cp;
237   char *toolfile;
238   char launcher_name[PATH_MAX+1];
239   char* new_line;
240   char** new_env;
241
242   /* Start the debugging-log system ASAP.  First find out how many
243      "-d"s were specified.  This is a pre-scan of the command line.
244      At the same time, look for the tool name. */
245   loglevel = 0;
246   for (i = 1; i < argc; i++) {
247      if (argv[i][0] != '-') {
248         clientname = argv[i];
249         break;
250      }
251      if (0 == strcmp(argv[i], "--")) {
252         if (i+1 < argc)
253            clientname = argv[i+1];
254         break;
255      }
256      if (0 == strcmp(argv[i], "-d"))
257         loglevel++;
258      if (0 == strncmp(argv[i], "--tool=", 7))
259         toolname = argv[i] + 7;
260   }
261
262   /* ... and start the debug logger.  Now we can safely emit logging
263      messages all through startup. */
264   VG_(debugLog_startup)(loglevel, "Stage 1");
265
266   /* Make sure we know which tool we're using */
267   if (toolname) {
268      VG_(debugLog)(1, "launcher", "tool '%s' requested\n", toolname);
269   } else {
270      VG_(debugLog)(1, "launcher",
271                       "no tool requested, defaulting to 'memcheck'\n");
272      toolname = "memcheck";
273   }
274
275   /* Select a platform to use if we can't decide that by looking at
276      the executable (eg because it's a shell script).  Note that the
277      default_platform is not necessarily either the primary or
278      secondary build target.  Instead it's chosen to maximise the
279      chances that /bin/sh will work on it.  Hence for a primary
280      target of ppc64-linux we still choose ppc32-linux as the default
281      target, because on most ppc64-linux setups, the basic /bin,
282      /usr/bin, etc, stuff is built in 32-bit mode, not 64-bit
283      mode. */
284   if ((0==strcmp(VG_PLATFORM,"x86-linux"))   ||
285       (0==strcmp(VG_PLATFORM,"amd64-linux")) ||
286       (0==strcmp(VG_PLATFORM,"ppc32-linux")) ||
287       (0==strcmp(VG_PLATFORM,"ppc64-linux")) ||
288       (0==strcmp(VG_PLATFORM,"arm-linux")))
289      default_platform = VG_PLATFORM;
290   else
291      barf("Unknown VG_PLATFORM '%s'", VG_PLATFORM);
292
293   /* Work out what platform to use, or use the default platform if
294      not possible. */
295   if (clientname == NULL) {
296      VG_(debugLog)(1, "launcher",
297                       "no client specified, defaulting platform to '%s'\n",
298                        default_platform);
299      platform = default_platform;
300   } else if ((platform = select_platform(clientname)) != NULL) {
301      VG_(debugLog)(1, "launcher", "selected platform '%s'\n", platform);
302   } else {
303      VG_(debugLog)(1, "launcher",
304                       "no platform detected, defaulting platform to '%s'\n",
305                       default_platform);
306      platform = default_platform;
307   }
308
309   /* Figure out the name of this executable (viz, the launcher), so
310      we can tell stage2.  stage2 will use the name for recursive
311      invocations of valgrind on child processes. */
312   memset(launcher_name, 0, PATH_MAX+1);
313   r = readlink("/proc/self/exe", launcher_name, PATH_MAX);
314   if (r == -1) {
315      /* If /proc/self/exe can't be followed, don't give up.  Instead
316         continue with an empty string for VALGRIND_LAUNCHER.  In the
317         sys_execve wrapper, this is tested, and if found to be empty,
318         fail the execve. */
319      fprintf(stderr, "valgrind: warning (non-fatal): "
320                      "readlink(\"/proc/self/exe\") failed.\n");
321      fprintf(stderr, "valgrind: continuing, however --trace-children=yes "
322                      "will not work.\n");
323   }
324
325   /* tediously augment the env: VALGRIND_LAUNCHER=launcher_name */
326   new_line = malloc(strlen(VALGRIND_LAUNCHER) + 1
327                     + strlen(launcher_name) + 1);
328   if (new_line == NULL)
329      barf("malloc of new_line failed.");
330   strcpy(new_line, VALGRIND_LAUNCHER);
331   strcat(new_line, "=");
332   strcat(new_line, launcher_name);
333
334   for (j = 0; envp[j]; j++)
335      ;
336   new_env = malloc((j+2) * sizeof(char*));
337   if (new_env == NULL)
338      barf("malloc of new_env failed.");
339   for (i = 0; i < j; i++)
340      new_env[i] = envp[i];
341   new_env[i++] = new_line;
342   new_env[i++] = NULL;
343   assert(i == j+2);
344
345   /* Establish the correct VALGRIND_LIB. */
346   cp = getenv(VALGRIND_LIB);
347
348   if (cp != NULL)
349      valgrind_lib = cp;
350
351   /* Build the stage2 invocation, and execve it.  Bye! */
352   toolfile = malloc(strlen(valgrind_lib) + strlen(toolname) + strlen(platform) + 3);
353   if (toolfile == NULL)
354      barf("malloc of toolfile failed.");
355   sprintf(toolfile, "%s/%s-%s", valgrind_lib, toolname, platform);
356
357   VG_(debugLog)(1, "launcher", "launching %s\n", toolfile);
358
359   execve(toolfile, argv, new_env);
360
361   fprintf(stderr, "valgrind: failed to start tool '%s' for platform '%s': %s\n",
362                   toolname, platform, strerror(errno));
363
364   exit(1);
365}
366