| /* ********************************************************** |
| * Copyright (c) 2010-2016 Google, Inc. All rights reserved. |
| * Copyright (c) 2010 VMware, Inc. All rights reserved. |
| * **********************************************************/ |
| |
| /* Dr. Memory: the memory debugger |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; |
| * version 2.1 of the License, and no later version. |
| |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. |
| */ |
| |
| /* front end for drstrace tool */ |
| |
| /* For unicode support, we must use wide-char versions of main(), argv[], |
| * and all of the windows library routines like GetEnvironmentVariable(), |
| * _access(), and GetFullPathName(). Yet we must use UTF-8 for the DR |
| * API routines. We could go two routes: one is to have everything be UTF-16 |
| * and only convert before calling DR routines; the other is to have everything |
| * be UTF-8 and convert when calling Windows routines. We pick the latter |
| * because we expect to port this to Linux. |
| */ |
| #ifdef WINDOWS |
| # define UNICODE |
| # define _UNICODE |
| #endif |
| |
| #include "dr_api.h" /* for the types */ |
| #include "dr_inject.h" |
| #include "dr_config.h" |
| #include "dr_frontend.h" |
| #include "utils.h" |
| #include <assert.h> |
| #include <stdio.h> |
| #include <time.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| /* XXX DRi#1079: can we put even more into drfrontendlib? DR location, client |
| * lib location, DR and client lib debug vs release, DR and client options, etc. |
| */ |
| |
| #define MAX_DR_CMDLINE (MAXIMUM_PATH*6) |
| #define MAX_APP_CMDLINE 4096 |
| |
| #define BIN32_ARCH "bin" |
| #define BIN64_ARCH "bin64" |
| #define LIB32_ARCH "lib32" |
| #define LIB64_ARCH "lib64" |
| |
| /* As this is a Windows tool, we tune it for startup and not steady-state perf. |
| * -fast_client_decode relies on drmgr, drx, and drsyscall support. |
| */ |
| /* FIXME i#1876: -fast_client_decode is causing app crashes on big Java apps. |
| * We disable for now but it would be nice to fix the bug and re-enable. |
| */ |
| #define DEFAULT_DR_OPS "-disable_traces -nop_initial_bblock" |
| |
| #define CLIENT_ID 0 |
| |
| #define prefix "" |
| |
| static bool verbose; |
| static bool quiet; |
| static bool results_to_stderr = true; |
| static bool no_resfile; /* no results file expected */ |
| static bool top_stats; |
| |
| #define fatal(msg, ...) do { \ |
| fprintf(stderr, "ERROR: " msg "\n", ##__VA_ARGS__); \ |
| fflush(stderr); \ |
| exit(1); \ |
| } while (0) |
| |
| #define warn(msg, ...) do { \ |
| if (!quiet) { \ |
| fprintf(stderr, "WARNING: " msg "\n", ##__VA_ARGS__); \ |
| fflush(stderr); \ |
| } \ |
| } while (0) |
| |
| #define info(msg, ...) do { \ |
| if (verbose) { \ |
| fprintf(stderr, "INFO: " msg "\n", ##__VA_ARGS__); \ |
| fflush(stderr); \ |
| } \ |
| } while (0) |
| |
| static void |
| print_usage(void) |
| { |
| fprintf(stderr, "usage: drstrace [options] -- <app and args to run>\n"); |
| /* XXX: have an optionsx.h? Shared frontend lib (i#1079) could help |
| * solve that by providing usage and options parsing for its provided |
| * options. |
| */ |
| fprintf(stderr, "-logdir <dir> Specify log directory where system call data\n"); |
| fprintf(stderr, " will be written, in a separate file per process.\n"); |
| fprintf(stderr, " The default value is \".\" (current dir).\n"); |
| fprintf(stderr, " If set to \"-\", data for all processes are\n"); |
| fprintf(stderr, " printed to stderr (warning: this can be slow).\n"); |
| fprintf(stderr, "-symcache_path <path> Specify absolute path where symbol data\n"); |
| fprintf(stderr, " should be cached. If not set, _NT_SYMBOL_PATH\n"); |
| fprintf(stderr, " environment variable will be used, if set; else\n"); |
| fprintf(stderr, " a local directory will be used.\n"); |
| fprintf(stderr, "-[no_]load_symbols Enables or disables loading of symbols over\n"); |
| fprintf(stderr, " the network. This option is enabled by default.\n"); |
| fprintf(stderr, "-no_follow_children Do not trace child processes (overrides\n"); |
| fprintf(stderr, " the default, which is to trace all children).\n"); |
| fprintf(stderr, "-version Print version number.\n"); |
| fprintf(stderr, "-verbose <N> Change verbosity (default 1).\n"); |
| } |
| |
| #define usage(msg, ...) do { \ |
| fprintf(stderr, "\n"); \ |
| fprintf(stderr, "ERROR: " msg "\n\n", ##__VA_ARGS__); \ |
| print_usage(); \ |
| exit(1); \ |
| } while (0) |
| |
| #undef BUFPRINT /* XXX: we could redefine ASSERT to use utils.h BUFPRINT here */ |
| /* must use dr_snprintf here to support %S converting UTF-16<->UTF-8 */ |
| #define BUFPRINT(buf, bufsz, sofar, len, ...) do { \ |
| drfront_status_t sc = drfront_bufprint(buf, bufsz, &(sofar), &(len), ##__VA_ARGS__); \ |
| if (sc != DRFRONT_SUCCESS) \ |
| fatal("drfront_bufprint failed: %d\n", sc); \ |
| } while (0) |
| |
| /* always null-terminates */ |
| static void |
| char_to_tchar(const char *str, TCHAR *wbuf, size_t wbuflen/*# elements*/) |
| { |
| drfront_status_t sc = drfront_char_to_tchar(str, wbuf, wbuflen); |
| if (sc != DRFRONT_SUCCESS) |
| fatal("drfront_char_to_tchar failed: %d\n", sc); |
| } |
| |
| /* Replace occurences of old_char with new_char in str. Typically used to |
| * canonicalize Windows paths into using forward slashes. |
| */ |
| void |
| string_replace_character(char *str, char old_char, char new_char) |
| { |
| while (*str != '\0') { |
| if (*str == old_char) { |
| *str = new_char; |
| } |
| str++; |
| } |
| } |
| |
| static bool |
| ends_in_exe(const char *s) |
| { |
| /* really we want caseless strstr */ |
| size_t len = strlen(s); |
| return (len > 4 && s[len-4] == '.' && |
| (s[len-3] == 'E' || s[len-3] == 'e') && |
| (s[len-2] == 'X' || s[len-2] == 'x') && |
| (s[len-1] == 'E' || s[len-1] == 'e')); |
| } |
| |
| static bool |
| file_is_readable(char *path) |
| { |
| bool ret = false; |
| return (drfront_access(path, DRFRONT_READ, &ret) == DRFRONT_SUCCESS && ret); |
| } |
| |
| static void |
| get_absolute_path(const char *src, char *buf, size_t buflen/*# elements*/) |
| { |
| drfront_status_t sc = drfront_get_absolute_path(src, buf, buflen); |
| if (sc != DRFRONT_SUCCESS) |
| fatal("drfront_get_absolute_path failed: %d\n", sc); |
| } |
| |
| static void |
| get_full_path(const char *app, char *buf, size_t buflen/*# elements*/) |
| { |
| drfront_status_t sc = drfront_get_app_full_path(app, buf, buflen); |
| if (sc != DRFRONT_SUCCESS) |
| fatal("drfront_get_app_full_path failed: %d\n", sc); |
| } |
| |
| int |
| _tmain(int argc, TCHAR *targv[]) |
| { |
| char **argv; |
| char *process = NULL; |
| char *dr_root = NULL; |
| char *drstrace_root = NULL; |
| char default_dr_root[MAXIMUM_PATH]; |
| char default_drstrace_root[MAXIMUM_PATH]; |
| char client_path[MAXIMUM_PATH]; |
| |
| const char *bin_arch = IF_X64_ELSE(BIN64_ARCH, BIN32_ARCH); |
| const char *lib_arch = IF_X64_ELSE(LIB64_ARCH, LIB32_ARCH); |
| |
| char client_ops[MAX_DR_CMDLINE]; |
| size_t cliops_sofar = 0; /* for BUFPRINT to client_ops */ |
| char dr_ops[MAX_DR_CMDLINE]; |
| char sym_path[MAXIMUM_PATH]; |
| char symsrv_path[MAXIMUM_PATH]; |
| char pdb_path[MAXIMUM_PATH]; |
| char dr_logdir[MAXIMUM_PATH]; |
| char symdll_path[MAXIMUM_PATH]; |
| |
| size_t drops_sofar = 0; /* for BUFPRINT to dr_ops */ |
| ssize_t len; /* shared by all BUFPRINT */ |
| |
| bool use_dr_debug = false; |
| bool use_drstrace_debug = false; |
| bool dr_logdir_specified = false; |
| bool sym_path_specified = false; |
| char *app_name; |
| char full_app_name[MAXIMUM_PATH]; |
| char **app_argv; |
| |
| int errcode; |
| void *inject_data; |
| int i; |
| char *c; |
| char buf[MAXIMUM_PATH]; |
| process_id_t pid; |
| bool exit0 = false; |
| |
| time_t start_time, end_time; |
| |
| drfront_status_t sc; |
| bool res; |
| bool is64, is32; |
| bool load_symbols = true; |
| |
| dr_standalone_init(); |
| |
| #if defined(WINDOWS) && !defined(_UNICODE) |
| # error _UNICODE must be defined |
| #else |
| /* Convert to UTF-8 if necessary */ |
| sc = drfront_convert_args((const TCHAR **)targv, &argv, argc); |
| if (sc != DRFRONT_SUCCESS) |
| fatal("failed to process args: %d\n", sc); |
| #endif |
| |
| /* Default root: we assume this exe is <root>/bin/drstrace.exe */ |
| get_full_path(argv[0], buf, BUFFER_SIZE_ELEMENTS(buf)); |
| c = buf + strlen(buf) - 1; |
| while (*c != DIRSEP && *c != ALT_DIRSEP && c > buf) |
| c--; |
| _snprintf(c+1, BUFFER_SIZE_ELEMENTS(buf) - (c+1-buf), "../dynamorio"); |
| NULL_TERMINATE_BUFFER(buf); |
| get_absolute_path(buf, default_dr_root, BUFFER_SIZE_ELEMENTS(default_dr_root)); |
| NULL_TERMINATE_BUFFER(default_dr_root); |
| dr_root = default_dr_root; |
| |
| /* assuming we're in bin/ (mainly due to CPack NSIS limitations) */ |
| _snprintf(c+1, BUFFER_SIZE_ELEMENTS(buf) - (c+1-buf), ".."); |
| NULL_TERMINATE_BUFFER(buf); |
| get_absolute_path(buf, default_drstrace_root, |
| BUFFER_SIZE_ELEMENTS(default_drstrace_root)); |
| NULL_TERMINATE_BUFFER(default_drstrace_root); |
| drstrace_root = default_drstrace_root; |
| string_replace_character(drstrace_root, ALT_DIRSEP, DIRSEP); /* canonicalize */ |
| |
| BUFPRINT(dr_ops, BUFFER_SIZE_ELEMENTS(dr_ops), |
| drops_sofar, len, "%s ", DEFAULT_DR_OPS); |
| |
| client_ops[0] = '\0'; |
| |
| /* parse command line */ |
| /* FIXME PR 487993: use optionsx.h to construct this parsing code */ |
| for (i=1; i<argc; i++) { |
| |
| /* note that we pass unknown args to client, until -- */ |
| if (strcmp(argv[i], "--") == 0) { |
| i++; |
| break; |
| } |
| /* drag-and-drop does not include "--" so we try to identify the app. */ |
| else if (argv[i][0] != '-' && ends_in_exe(argv[i])) { |
| /* leave i alone: this is the app itself */ |
| break; |
| } |
| else if (strcmp(argv[i], "-v") == 0) { |
| verbose = true; |
| continue; |
| } |
| else if (strcmp(argv[i], "-dr_debug") == 0) { |
| use_dr_debug = true; |
| continue; |
| } |
| else if (strcmp(argv[i], "-dr_release") == 0) { |
| use_dr_debug = false; |
| continue; |
| } |
| else if (strcmp(argv[i], "-debug") == 0) { |
| use_drstrace_debug = true; |
| continue; |
| } |
| else if (strcmp(argv[i], "-release") == 0) { |
| use_drstrace_debug = false; |
| continue; |
| } |
| else if (!strcmp(argv[i], "-version")) { |
| #if defined(BUILD_NUMBER) && defined(VERSION_NUMBER) |
| printf("Dr. Memory drstrace version %s -- build %d\n", |
| VERSION_STRING, BUILD_NUMBER); |
| #elif defined(BUILD_NUMBER) |
| printf("Dr. Memory drstrace custom build %d -- %s\n", BUILD_NUMBER, __DATE__); |
| #elif defined(VERSION_NUMBER) |
| printf("Dr. Memory drstrace version %s -- custom build %s, %s\n", |
| VERSION_STRING, __DATE__, __TIME__); |
| #else |
| printf("Dr. Memory drstrace custom build -- %s, %s\n", __DATE__, __TIME__); |
| #endif |
| exit(0); |
| } |
| else if (strcmp(argv[i], "-dr") == 0) { |
| if (i >= argc - 1) |
| usage("invalid arguments"); |
| dr_root = argv[++i]; |
| } |
| else if (strcmp(argv[i], "-drstrace") == 0) { |
| if (i >= argc - 1) |
| usage("invalid arguments"); |
| drstrace_root = argv[++i]; |
| } |
| else if (strcmp(argv[i], "-follow_children") == 0 || |
| strcmp(argv[i], "-no_follow_children") == 0) { |
| BUFPRINT(dr_ops, BUFFER_SIZE_ELEMENTS(dr_ops), |
| drops_sofar, len, "%s ", argv[i]); |
| } |
| else if (strcmp(argv[i], "-dr_ops") == 0) { |
| if (i >= argc - 1) |
| usage("invalid arguments"); |
| if (strstr(argv[i+1], "-logdir ") != NULL) |
| dr_logdir_specified = true; |
| BUFPRINT(dr_ops, BUFFER_SIZE_ELEMENTS(dr_ops), |
| drops_sofar, len, "%s ", argv[++i]); |
| } |
| else if (strcmp(argv[i], "-exit0") == 0) { |
| exit0 = true; |
| } |
| else if (strcmp(argv[i], "-symcache_path") == 0) { |
| _snprintf(sym_path, BUFFER_SIZE_ELEMENTS(sym_path), |
| "%s", argv[++i]); |
| NULL_TERMINATE_BUFFER(sym_path); |
| string_replace_character(sym_path, '\\', '/'); |
| sym_path_specified = true; |
| } |
| else if (strcmp(argv[i], "-load_symbols") == 0) { |
| load_symbols = true; |
| } |
| else if (strcmp(argv[i], "-no_load_symbols") == 0) { |
| load_symbols = false; |
| } |
| else { |
| /* pass to client */ |
| BUFPRINT(client_ops, BUFFER_SIZE_ELEMENTS(client_ops), |
| cliops_sofar, len, "`%s` ", argv[i]); |
| } |
| } |
| |
| if (i >= argc) |
| usage("%s", "no app specified"); |
| app_name = argv[i]; |
| get_full_path(app_name, full_app_name, BUFFER_SIZE_ELEMENTS(full_app_name)); |
| if (full_app_name[0] != '\0') |
| app_name = full_app_name; |
| info("targeting application: \"%s\"", app_name); |
| |
| /* Cross-arch injection (i#1506) */ |
| if (drfront_is_64bit_app(app_name, &is64, &is32) == DRFRONT_SUCCESS && |
| IF_X64_ELSE(!is64, is64 && !is32)) { |
| /* While I'd love to just set bin_arch and lib_arch differently, |
| * drinjectlib doesn't support cross-arch injection (DRi#803). |
| * Thus, to provide single-front-end support, we launch the other |
| * frontend. |
| */ |
| char *orig_argv0 = argv[0]; |
| _snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), |
| "%s%c%s%cdrstrace.exe", drstrace_root, DIRSEP, |
| IF_X64_ELSE(BIN32_ARCH, BIN64_ARCH), DIRSEP); |
| NULL_TERMINATE_BUFFER(buf); |
| if (!file_is_readable(buf)) { |
| fatal("unable to find frontend %s to match target app bitwidth: " |
| "is this an incomplete installation?", buf); |
| } |
| argv[0] = buf; |
| info("launching frontend %s to match target app bitwidth", buf); |
| /* XXX DRi#943: this lib routine currently doesn't handle int18n */ |
| errcode = dr_inject_process_create(buf, argv, &inject_data); |
| /* Mismatch is just a warning */ |
| if (errcode == 0 || errcode == WARN_IMAGE_MACHINE_TYPE_MISMATCH_EXE) { |
| dr_inject_process_run(inject_data); |
| /* If we don't wait, the prompt comes back, which is confusing */ |
| info("waiting for other frontend..."); |
| errcode = WaitForSingleObject(dr_inject_get_process_handle(inject_data), |
| INFINITE); |
| if (errcode != WAIT_OBJECT_0) |
| info("failed to wait for frontend: %d\n", errcode); |
| dr_inject_process_exit(inject_data, false); |
| argv[0] = orig_argv0; |
| goto cleanup; |
| } else { |
| fatal("unable to launch frontend to match target app bitwidth: code=%d", |
| errcode); |
| } |
| } |
| |
| /* note that we want target app name as part of cmd line |
| * (FYI: if we were using WinMain, the pzsCmdLine passed in |
| * does not have our own app name in it) |
| * it's easier to construct than to call GetCommandLine() and then |
| * remove our own args. |
| */ |
| app_argv = &argv[i]; |
| if (verbose) { |
| int j; |
| c = buf; |
| for (j = 0; app_argv[j] != NULL; j++) { |
| c += _snprintf(c, BUFFER_SIZE_ELEMENTS(buf) - (c - buf), |
| "\"%s\" ", app_argv[j]); |
| } |
| NULL_TERMINATE_BUFFER(buf); |
| assert(c - buf < BUFFER_SIZE_ELEMENTS(buf)); |
| info("app cmdline: %s", buf); |
| } |
| |
| if (!file_is_readable(dr_root)) { |
| fatal("invalid -dr_root %s", dr_root); |
| goto error; /* actually won't get here */ |
| } |
| if (dr_root != default_dr_root) { |
| /* Workaround for DRi#1082 where DR root path can't have ".." */ |
| get_absolute_path(dr_root, default_dr_root, |
| BUFFER_SIZE_ELEMENTS(default_dr_root)); |
| NULL_TERMINATE_BUFFER(default_dr_root); |
| dr_root = default_dr_root; |
| } |
| _snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), |
| "%s/%s/%s/dynamorio.dll", dr_root, lib_arch, |
| use_dr_debug ? "debug" : "release"); |
| NULL_TERMINATE_BUFFER(buf); |
| if (!file_is_readable(buf)) { |
| /* support debug build w/ integrated debug DR build and so no release */ |
| if (!use_dr_debug) { |
| _snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), |
| "%s/%s/%s/dynamorio.dll", dr_root, lib_arch, "debug"); |
| NULL_TERMINATE_BUFFER(buf); |
| if (!file_is_readable(buf)) { |
| fatal("cannot find DynamoRIO library %s", buf); |
| goto error; /* actually won't get here */ |
| } |
| warn("using debug DynamoRIO since release not found"); |
| use_dr_debug = true; |
| } |
| } |
| |
| _snprintf(client_path, BUFFER_SIZE_ELEMENTS(client_path), |
| "%s%c%s%c%s%cdrstracelib.dll", drstrace_root, DIRSEP, bin_arch, DIRSEP, |
| use_drstrace_debug ? "debug" : "release", DIRSEP); |
| NULL_TERMINATE_BUFFER(client_path); |
| if (!file_is_readable(client_path)) { |
| if (!use_drstrace_debug) { |
| _snprintf(client_path, BUFFER_SIZE_ELEMENTS(client_path), |
| "%s%c%s%c%s%cdrstracelib.dll", drstrace_root, |
| DIRSEP, bin_arch, DIRSEP, "debug", DIRSEP); |
| NULL_TERMINATE_BUFFER(client_path); |
| if (!file_is_readable(client_path)) { |
| fatal("invalid -drstrace_root: cannot find %s", client_path); |
| goto error; /* actually won't get here */ |
| } |
| /* try to avoid warning for devs running from build dir */ |
| _snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), |
| "%s%cCMakeCache.txt", drstrace_root, DIRSEP); |
| NULL_TERMINATE_BUFFER(buf); |
| if (!file_is_readable(buf)) |
| warn("using debug Dr. Memory since release not found"); |
| use_drstrace_debug = true; |
| } |
| } |
| |
| /* If we're installed into Program Files, we have to pick a different |
| * DR logdir to avoid popup msgs (i#1499). We don't want to use the |
| * same logdir as for drstrace as the latter supports "-" (stderr). |
| */ |
| if (!dr_logdir_specified) { /* don't override user-specified DR logdir */ |
| bool use_root; |
| /* XXX: ideally we would share DrMem's "/dynamorio/" subdir, but that would |
| * require creating both subdirs separately if drstrace is run before drmem. |
| * See comment below as well. |
| */ |
| if (drfront_appdata_logdir(dr_root, "Dr. Memory", &use_root, |
| dr_logdir, BUFFER_SIZE_ELEMENTS(dr_logdir)) != |
| DRFRONT_SUCCESS || |
| use_root || |
| (!dr_create_dir(dr_logdir) && !dr_directory_exists(dr_logdir))) { |
| /* A similar situation: we'd prefer to share DrMem's local install |
| * "drmemory/logs/dynamorio" but that gets complex to support both |
| * in a package and in a dev's local build dir. Since DR logs |
| * are going to be rare w/ drstrace (only for debugging the tool |
| * itself) we just go w/ simplicity. |
| */ |
| get_absolute_path(".", dr_logdir, BUFFER_SIZE_ELEMENTS(dr_logdir)); |
| } |
| BUFPRINT(dr_ops, BUFFER_SIZE_ELEMENTS(dr_ops), |
| drops_sofar, len, "-logdir `%s` ", dr_logdir); |
| } |
| |
| if (!sym_path_specified) { |
| /* Default location for local symbol cache: if our install dir is |
| * writable, we want logs/symbols/. Else just symbols/ inside |
| * AppData Dr. Memory dir. |
| * drfront_set_client_symbol_search_path() adds symbols/ for us. |
| */ |
| bool use_root; |
| sc = drfront_appdata_logdir(drstrace_root, "Dr. Memory", &use_root, |
| sym_path, BUFFER_SIZE_ELEMENTS(sym_path)); |
| if (sc == DRFRONT_SUCCESS) { |
| if (use_root) { |
| _snprintf(sym_path, BUFFER_SIZE_ELEMENTS(sym_path), |
| "%s%clogs", drstrace_root, DIRSEP); |
| NULL_TERMINATE_BUFFER(sym_path); |
| } |
| if (!dr_create_dir(sym_path) && !dr_directory_exists(sym_path)) |
| sc = DRFRONT_ERROR; |
| } |
| if (sc != DRFRONT_SUCCESS) { |
| get_absolute_path(".", sym_path, BUFFER_SIZE_ELEMENTS(sym_path)); |
| } |
| } |
| |
| /* fetch wintypes.pdb (if not exists) to symcache_path */ |
| if (drfront_sym_init(NULL, "dbghelp.dll") == DRFRONT_SUCCESS) { |
| sc = drfront_set_client_symbol_search_path |
| (sym_path, sym_path_specified, |
| symsrv_path, BUFFER_SIZE_ELEMENTS(symsrv_path)); |
| if (sc == DRFRONT_SUCCESS) { |
| /* symfetch.dll is in our dir */ |
| get_full_path(argv[0], buf, BUFFER_SIZE_ELEMENTS(buf)); |
| c = buf + strlen(buf) - 1; |
| while (*c != DIRSEP && *c != ALT_DIRSEP && c > buf) |
| c--; |
| _snprintf(c+1, BUFFER_SIZE_ELEMENTS(buf) - (c+1-buf), "%s", SYMBOL_DLL_NAME); |
| NULL_TERMINATE_BUFFER(buf); |
| get_absolute_path(buf, symdll_path, BUFFER_SIZE_ELEMENTS(symdll_path)); |
| NULL_TERMINATE_BUFFER(symdll_path); |
| /* before we add the MS symsrv, see whether we have local symbols */ |
| sc = drfront_fetch_module_symbols(symdll_path, pdb_path, |
| BUFFER_SIZE_ELEMENTS(pdb_path)); |
| if (sc != DRFRONT_SUCCESS && load_symbols) { |
| warn("fetching symbol information (procedure may take some time)."); |
| sc = drfront_set_symbol_search_path(symsrv_path); |
| /* We use a special fake dll to obtain symbolic info from MS Symbol |
| * server. PTAL i#1540 for details. |
| */ |
| if (sc == DRFRONT_SUCCESS) { |
| sc = drfront_fetch_module_symbols(symdll_path, pdb_path, |
| BUFFER_SIZE_ELEMENTS(pdb_path)); |
| if (sc == DRFRONT_SUCCESS) |
| info("symbol file successfully fetched"); |
| } |
| } |
| if (sc == DRFRONT_SUCCESS) { |
| /* pass to client */ |
| BUFPRINT(client_ops, BUFFER_SIZE_ELEMENTS(client_ops), |
| cliops_sofar, len, "-symcache_path `%s` ", pdb_path); |
| } else if (!load_symbols) { |
| warn("symbol fetching was disabled via -no_load_symbols."); |
| } else { |
| warn("symbol fetching failed. Symbol lookup will be disabled."); |
| } |
| } else { |
| warn("failed to set symbol search path. Symbol lookup will be disabled."); |
| } |
| } else { |
| warn("symbol initialization error. Symbol lookup will be disabled."); |
| } |
| |
| /* i#1638: fall back to temp dirs if there's no HOME/USERPROFILE set */ |
| dr_get_config_dir(false/*local*/, true/*use temp*/, buf, BUFFER_SIZE_ELEMENTS(buf)); |
| info("DynamoRIO configuration directory is %s", buf); |
| |
| #ifdef UNIX |
| errcode = dr_inject_prepare_to_exec(app_name, (const char **)app_argv, &inject_data); |
| #else |
| errcode = dr_inject_process_create(app_name, (const char **)app_argv, &inject_data); |
| #endif |
| /* Mismatch is just a warning */ |
| if (errcode != 0 && errcode != WARN_IMAGE_MACHINE_TYPE_MISMATCH_EXE) { |
| #ifdef WINDOWS |
| int sofar = |
| #endif |
| _snprintf(buf, BUFFER_SIZE_ELEMENTS(buf), |
| "failed to create process for \"%s\": ", app_name); |
| #ifdef WINDOWS |
| if (sofar > 0) { |
| FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, |
| NULL, errcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), |
| (LPTSTR) buf + sofar, |
| BUFFER_SIZE_ELEMENTS(buf) - sofar*sizeof(char), NULL); |
| } |
| NULL_TERMINATE_BUFFER(buf); |
| #endif |
| fatal("%s", buf); |
| goto error; /* actually won't get here */ |
| } |
| |
| pid = dr_inject_get_process_id(inject_data); |
| |
| process = dr_inject_get_image_name(inject_data); |
| /* we don't care if this app is already registered for DR b/c our |
| * this-pid config will override |
| */ |
| info("configuring %s pid=%d dr_ops=\"%s\"", process, pid, dr_ops); |
| if (dr_register_process(process, pid, |
| false/*local*/, dr_root, DR_MODE_CODE_MANIPULATION, |
| use_dr_debug, DR_PLATFORM_DEFAULT, dr_ops) != DR_SUCCESS) { |
| fatal("failed to register DynamoRIO configuration"); |
| goto error; /* actually won't get here */ |
| } |
| info("configuring client \"%s\" ops=\"%s\"", client_path, client_ops); |
| if (dr_register_client(process, pid, |
| false/*local*/, DR_PLATFORM_DEFAULT, CLIENT_ID, |
| 0, client_path, client_ops) != DR_SUCCESS) { |
| fatal("failed to register DynamoRIO client configuration"); |
| goto error; /* actually won't get here */ |
| } |
| if (!dr_inject_process_inject(inject_data, false/*!force*/, NULL)) { |
| fatal("unable to inject"); |
| goto error; /* actually won't get here */ |
| } |
| |
| if (top_stats) |
| start_time = time(NULL); |
| dr_inject_process_run(inject_data); |
| #ifdef UNIX |
| fatal("failed to exec application"); |
| #else |
| info("waiting for app to exit..."); |
| errcode = WaitForSingleObject(dr_inject_get_process_handle(inject_data), INFINITE); |
| if (errcode != WAIT_OBJECT_0) |
| info("failed to wait for app: %d\n", errcode); |
| #endif |
| if (top_stats) { |
| double wallclock; |
| end_time = time(NULL); |
| wallclock = difftime(end_time, start_time); |
| dr_inject_print_stats(inject_data, (int) wallclock, true/*time*/, true/*mem*/); |
| } |
| errcode = dr_inject_process_exit(inject_data, false/*don't kill process*/); |
| goto cleanup; |
| error: |
| dr_inject_process_exit(inject_data, false); |
| errcode = 1; |
| cleanup: |
| sc = drfront_cleanup_args(argv, argc); |
| if (sc != DRFRONT_SUCCESS) |
| fatal("drfront_cleanup_args failed: %d\n", sc); |
| return (exit0 ? 0 : errcode); |
| } |
