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 (at) 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)) 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 */ 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 */ 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 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
