coregrind/m_options.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Command line options.                            m_options.c ---*/
   4 /*--------------------------------------------------------------------*/
   5
   6 /*
   7    This file is part of Valgrind, a dynamic binary instrumentation
   8    framework.
   9
  10    Copyright (C) 2000-2017 Nicholas Nethercote
  11       njn@valgrind.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 #include "pub_core_basics.h"
  32 #include "pub_core_vki.h"
  33 #include "pub_core_options.h"
  34 #include "pub_core_libcassert.h"
  35 #include "pub_core_libcbase.h"
  36 #include "pub_core_libcfile.h"
  37 #include "pub_core_libcprint.h"
  38 #include "pub_core_libcproc.h"
  39 #include "pub_core_mallocfree.h"
  40 #include "pub_core_seqmatch.h"     // VG_(string_match)
  41 #include "pub_core_aspacemgr.h"
  42
  43 // See pub_{core,tool}_options.h for explanations of all these.
  44
  45
  46 /* Define, and set defaults. */
  47
  48 const HChar *VG_(clo_toolname) = "memcheck";    // default to Memcheck
  49 VexControl VG_(clo_vex_control);
  50 VexRegisterUpdates VG_(clo_px_file_backed) = VexRegUpd_INVALID;
  51
  52 Bool   VG_(clo_error_limit)    = True;
  53 Int    VG_(clo_error_exitcode) = 0;
  54 HChar *VG_(clo_error_markers)[2] = {NULL, NULL};
  55 Bool   VG_(clo_exit_on_first_error) = False;
  56
  57 Bool   VG_(clo_show_error_list) = False;
  58
  59 #if defined(VGPV_arm_linux_android) \
  60     || defined(VGPV_x86_linux_android) \
  61     || defined(VGPV_mips32_linux_android) \
  62     || defined(VGPV_arm64_linux_android)
  63 VgVgdb VG_(clo_vgdb)           = Vg_VgdbNo; // currently disabled on Android
  64 #else
  65 VgVgdb VG_(clo_vgdb)           = Vg_VgdbYes;
  66 #endif
  67 Int    VG_(clo_vgdb_poll)      = 5000;
  68 Int    VG_(clo_vgdb_error)     = 999999999;
  69 UInt   VG_(clo_vgdb_stop_at)   = 0;
  70 const HChar *VG_(clo_vgdb_prefix)    = NULL;
  71 const HChar *VG_(arg_vgdb_prefix)    = NULL;
  72 Bool   VG_(clo_vgdb_shadow_registers) = False;
  73
  74 Int    VG_(clo_gen_suppressions) = 0;
  75 Int    VG_(clo_sanity_level)   = 1;
  76 Int    VG_(clo_verbosity)      = 1;
  77 Bool   VG_(clo_stats)          = False;
  78 Bool   VG_(clo_xml)            = False;
  79 const HChar* VG_(clo_xml_user_comment) = NULL;
  80 Bool   VG_(clo_demangle)       = True;
  81 const HChar* VG_(clo_soname_synonyms)    = NULL;
  82 Bool   VG_(clo_trace_children) = False;
  83 const HChar* VG_(clo_trace_children_skip) = NULL;
  84 const HChar* VG_(clo_trace_children_skip_by_arg) = NULL;
  85 Bool   VG_(clo_child_silent_after_fork) = False;
  86 const HChar *VG_(clo_log_fname_unexpanded) = NULL;
  87 const HChar *VG_(clo_xml_fname_unexpanded) = NULL;
  88 Bool   VG_(clo_time_stamp)     = False;
  89 Int    VG_(clo_input_fd)       = 0; /* stdin */
  90 Bool   VG_(clo_default_supp)   = True;
  91 XArray *VG_(clo_suppressions);   // array of strings
  92 XArray *VG_(clo_fullpath_after); // array of strings
  93 const HChar* VG_(clo_extra_debuginfo_path) = NULL;
  94 const HChar* VG_(clo_debuginfo_server) = NULL;
  95 Bool   VG_(clo_allow_mismatched_debuginfo) = False;
  96 UChar  VG_(clo_trace_flags)    = 0; // 00000000b
  97 Bool   VG_(clo_profyle_sbs)    = False;
  98 UChar  VG_(clo_profyle_flags)  = 0; // 00000000b
  99 ULong  VG_(clo_profyle_interval) = 0;
 100 Int    VG_(clo_trace_notbelow) = -1;  // unspecified
 101 Int    VG_(clo_trace_notabove) = -1;  // unspecified
 102 Bool   VG_(clo_trace_syscalls) = False;
 103 Bool   VG_(clo_trace_signals)  = False;
 104 Bool   VG_(clo_trace_symtab)   = False;
 105 const HChar* VG_(clo_trace_symtab_patt) = "*";
 106 Bool   VG_(clo_trace_cfi)      = False;
 107 Bool   VG_(clo_debug_dump_syms) = False;
 108 Bool   VG_(clo_debug_dump_line) = False;
 109 Bool   VG_(clo_debug_dump_frames) = False;
 110 Bool   VG_(clo_trace_redir)    = False;
 111 enum FairSchedType
 112        VG_(clo_fair_sched)     = disable_fair_sched;
 113 Bool   VG_(clo_trace_sched)    = False;
 114 Bool   VG_(clo_profile_heap)   = False;
 115 UInt   VG_(clo_progress_interval) = 0; /* in seconds, 1 .. 3600,
 116                                           or 0 == disabled */
 117 Int    VG_(clo_core_redzone_size) = CORE_REDZONE_DEFAULT_SZB;
 118 // A value != -1 overrides the tool-specific value
 119 // VG_(needs_malloc_replacement).tool_client_redzone_szB
 120 Int    VG_(clo_redzone_size)   = -1;
 121 VgXTMemory VG_(clo_xtree_memory) =  Vg_XTMemory_None;
 122 const HChar* VG_(clo_xtree_memory_file) = "xtmemory.kcg.%p";
 123 Bool VG_(clo_xtree_compress_strings) = True;
 124
 125 Int    VG_(clo_dump_error)     = 0;
 126 Int    VG_(clo_backtrace_size) = 12;
 127 Int    VG_(clo_merge_recursive_frames) = 0; // default value: no merge
 128 UInt   VG_(clo_sim_hints)      = 0;
 129 Bool   VG_(clo_sym_offsets)    = False;
 130 Bool   VG_(clo_read_inline_info) = False; // Or should be put it to True by default ???
 131 Bool   VG_(clo_read_var_info)  = False;
 132 XArray *VG_(clo_req_tsyms);  // array of strings
 133 Bool   VG_(clo_run_libc_freeres) = True;
 134 Bool   VG_(clo_run_cxx_freeres) = True;
 135 Bool   VG_(clo_track_fds)      = False;
 136 Bool   VG_(clo_show_below_main)= False;
 137 Bool   VG_(clo_keep_debuginfo) = False;
 138 Bool   VG_(clo_show_emwarns)   = False;
 139 Word   VG_(clo_max_stackframe) = 2000000;
 140 UInt   VG_(clo_max_threads)    = MAX_THREADS_DEFAULT;
 141 Word   VG_(clo_main_stacksize) = 0; /* use client's rlimit.stack */
 142 Word   VG_(clo_valgrind_stacksize) = VG_DEFAULT_STACK_ACTIVE_SZB;
 143 Bool   VG_(clo_wait_for_gdb)   = False;
 144 UInt   VG_(clo_kernel_variant) = 0;
 145 Bool   VG_(clo_dsymutil)       = True;
 146 Bool   VG_(clo_sigill_diag)    = True;
 147 UInt   VG_(clo_unw_stack_scan_thresh) = 0; /* disabled by default */
 148 UInt   VG_(clo_unw_stack_scan_frames) = 5;
 149
 150 // Set clo_smc_check so that it provides transparent self modifying
 151 // code support for "correct" programs at the smallest achievable
 152 // expense for this arch.
 153 #if defined(VGA_x86) || defined(VGA_amd64) || defined(VGA_s390x)
 154 VgSmc VG_(clo_smc_check) = Vg_SmcAllNonFile;
 155 #elif defined(VGA_ppc32) || defined(VGA_ppc64be) || defined(VGA_ppc64le) \
 156       || defined(VGA_arm) || defined(VGA_arm64) \
 157       || defined(VGA_mips32) || defined(VGA_mips64)
 158 VgSmc VG_(clo_smc_check) = Vg_SmcStack;
 159 #else
 160 #  error "Unknown arch"
 161 #endif
 162
 163 #if defined(VGO_darwin)
 164 UInt VG_(clo_resync_filter) = 1; /* enabled, but quiet */
 165 #else
 166 UInt VG_(clo_resync_filter) = 0; /* disabled */
 167 #endif
 168
 169
 170 /*====================================================================*/
 171 /*=== File expansion                                               ===*/
 172 /*====================================================================*/
 173
 174 // Copies the string, prepending it with the startup working directory, and
 175 // expanding %p and %q entries.  Returns a new, malloc'd string.
 176 HChar* VG_(expand_file_name)(const HChar* option_name, const HChar* format)
 177 {
 178    const HChar *base_dir;
 179    Int len, i = 0, j = 0;
 180    HChar* out;
 181    const HChar *message = NULL;
 182
 183    base_dir = VG_(get_startup_wd)();
 184
 185    if (VG_STREQ(format, "")) {
 186       // Empty name, bad.
 187       message = "No filename given\n";
 188       goto bad;
 189    }
 190
 191    // If 'format' starts with a '~', abort -- the user probably expected the
 192    // shell to expand but it didn't (see bug 195268 for details).  This means
 193    // that we don't allow a legitimate filename beginning with '~' but that
 194    // seems very unlikely.
 195    if (format[0] == '~') {
 196       message =
 197          "Filename begins with '~'\n"
 198          "You probably expected the shell to expand the '~', but it\n"
 199          "didn't.  The rules for '~'-expansion vary from shell to shell.\n"
 200          "You might have more luck using $HOME instead.\n";
 201       goto bad;
 202    }
 203
 204    len = VG_(strlen)(format) + 1;
 205    out = VG_(malloc)( "options.efn.1", len );
 206
 207 #define ENSURE_THIS_MUCH_SPACE(x) \
 208    if (j + x >= len) { \
 209       len += (10 + x); \
 210       out = VG_(realloc)("options.efn.2(multiple)", out, len); \
 211    }
 212
 213    while (format[i]) {
 214       if (format[i] != '%') {
 215          ENSURE_THIS_MUCH_SPACE(1);
 216          out[j++] = format[i++];
 217
 218       } else {
 219          // We saw a '%'.  What's next...
 220          i++;
 221          if      ('%' == format[i]) {
 222             // Replace '%%' with '%'.
 223             ENSURE_THIS_MUCH_SPACE(1);
 224             out[j++] = format[i++];
 225          }
 226          else if ('p' == format[i]) {
 227             // Print the PID.  Assume that it's not longer than 10 chars --
 228             // reasonable since 'pid' is an Int (ie. 32 bits).
 229             Int pid = VG_(getpid)();
 230             ENSURE_THIS_MUCH_SPACE(10);
 231             j += VG_(sprintf)(&out[j], "%d", pid);
 232             i++;
 233          }
 234          else if ('n' == format[i]) {
 235             // Print a seq nr.
 236             static Int last_pid;
 237             static Int seq_nr;
 238             Int pid = VG_(getpid)();
 239             if (last_pid != pid)
 240                seq_nr = 0;
 241             last_pid = pid;
 242             seq_nr++;
 243             ENSURE_THIS_MUCH_SPACE(10);
 244             j += VG_(sprintf)(&out[j], "%d", seq_nr);
 245             i++;
 246          }
 247          else if ('q' == format[i]) {
 248             i++;
 249             if ('{' == format[i]) {
 250                // Get the env var name, print its contents.
 251                HChar *qual;
 252                Int begin_qualname = ++i;
 253                while (True) {
 254                   if (0 == format[i]) {
 255                      message = "Missing '}' in %q specifier\n";
 256                      goto bad;
 257                   } else if ('}' == format[i]) {
 258                      Int qualname_len = i - begin_qualname;
 259                      HChar qualname[qualname_len + 1];
 260                      VG_(strncpy)(qualname, format + begin_qualname,
 261                                   qualname_len);
 262                      qualname[qualname_len] = '\0';
 263                      qual = VG_(getenv)(qualname);
 264                      if (NULL == qual) {
 265                         // This memory will leak, But we don't care because
 266                         // VG_(fmsg_bad_option) will terminate the process.
 267                         HChar *str = VG_(malloc)("options.efn.3",
 268                                                  100 + qualname_len);
 269                         VG_(sprintf)(str,
 270                                      "Environment variable '%s' is not set\n",
 271                                      qualname);
 272                         message = str;
 273                         goto bad;
 274                      }
 275                      i++;
 276                      break;
 277                   }
 278                   i++;
 279                }
 280                ENSURE_THIS_MUCH_SPACE(VG_(strlen)(qual));
 281                j += VG_(sprintf)(&out[j], "%s", qual);
 282             } else {
 283                message = "Expected '{' after '%q'\n";
 284                goto bad;
 285             }
 286          }
 287          else {
 288             // Something else, abort.
 289             message = "Expected 'p' or 'q' or '%' after '%'\n";
 290             goto bad;
 291          }
 292       }
 293    }
 294    ENSURE_THIS_MUCH_SPACE(1);
 295    out[j++] = 0;
 296
 297    // If 'out' is not an absolute path name, prefix it with the startup dir.
 298    if (out[0] != '/') {
 299       if (base_dir == NULL) {
 300          message = "Current working dir doesn't exist, use absolute path\n";
 301          goto bad;
 302       }
 303       len = VG_(strlen)(base_dir) + 1 + VG_(strlen)(out) + 1;
 304
 305       HChar *absout = VG_(malloc)("options.efn.4", len);
 306       VG_(strcpy)(absout, base_dir);
 307       VG_(strcat)(absout, "/");
 308       VG_(strcat)(absout, out);
 309       VG_(free)(out);
 310       out = absout;
 311    }
 312
 313    return out;
 314
 315   bad: {
 316    vg_assert(message != NULL);
 317    // 2:  1 for the '=', 1 for the NUL.
 318    HChar opt[VG_(strlen)(option_name) + VG_(strlen)(format) + 2];
 319    VG_(sprintf)(opt, "%s=%s", option_name, format);
 320    VG_(fmsg_bad_option)(opt, "%s", message);
 321   }
 322 }
 323
 324 /*====================================================================*/
 325 /*=== --trace-children= support                                    ===*/
 326 /*====================================================================*/
 327
 328 static HChar const* consume_commas ( HChar const* c ) {
 329    while (*c && *c == ',') {
 330       ++c;
 331    }
 332    return c;
 333 }
 334
 335 static HChar const* consume_field ( HChar const* c ) {
 336    while (*c && *c != ',') {
 337       ++c;
 338    }
 339    return c;
 340 }
 341
 342 /* Should we trace into this child executable (across execve, spawn etc) ?
 343    This involves considering --trace-children=,
 344    --trace-children-skip=, --trace-children-skip-by-arg=, and the name
 345    of the executable.  'child_argv' must not include the name of the
 346    executable itself; iow child_argv[0] must be the first arg, if any,
 347    for the child. */
 348 Bool VG_(should_we_trace_this_child) ( const HChar* child_exe_name,
 349                                        const HChar** child_argv )
 350 {
 351    // child_exe_name is pulled out of the guest's space.  We
 352    // should be at least marginally cautious with it, lest it
 353    // explode or burst into flames unexpectedly.
 354    if (child_exe_name == NULL || VG_(strlen)(child_exe_name) == 0)
 355       return VG_(clo_trace_children);  // we know narfink
 356
 357    // If --trace-children=no, the answer is simply NO.
 358    if (! VG_(clo_trace_children))
 359       return False;
 360
 361    // Otherwise, look for other reasons to say NO.  First,
 362    // see if the exe name matches any of the patterns specified
 363    // by --trace-children-skip=.
 364    if (VG_(clo_trace_children_skip)) {
 365       HChar const* last = VG_(clo_trace_children_skip);
 366       HChar const* name = child_exe_name;
 367       while (*last) {
 368          Bool   matches;
 369          HChar* patt;
 370          HChar const* first = consume_commas(last);
 371          last = consume_field(first);
 372          if (first == last)
 373             break;
 374          vg_assert(last > first);
 375          /* copy the candidate string into a temporary malloc'd block
 376             so we can use VG_(string_match) on it. */
 377          patt = VG_(calloc)("m_options.swttc.1", last - first + 1, 1);
 378          VG_(memcpy)(patt, first, last - first);
 379          vg_assert(patt[last-first] == 0);
 380          matches = VG_(string_match)(patt, name);
 381          VG_(free)(patt);
 382          if (matches)
 383             return False;
 384       }
 385    }
 386
 387    // Check if any of the args match any of the patterns specified
 388    // by --trace-children-skip-by-arg=.
 389    if (VG_(clo_trace_children_skip_by_arg) && child_argv != NULL) {
 390       HChar const* last = VG_(clo_trace_children_skip_by_arg);
 391       while (*last) {
 392          Int    i;
 393          Bool   matches;
 394          HChar* patt;
 395          HChar const* first = consume_commas(last);
 396          last = consume_field(first);
 397          if (first == last)
 398             break;
 399          vg_assert(last > first);
 400          /* copy the candidate string into a temporary malloc'd block
 401             so we can use VG_(string_match) on it. */
 402          patt = VG_(calloc)("m_options.swttc.1", last - first + 1, 1);
 403          VG_(memcpy)(patt, first, last - first);
 404          vg_assert(patt[last-first] == 0);
 405          for (i = 0; child_argv[i]; i++) {
 406             matches = VG_(string_match)(patt, child_argv[i]);
 407             if (matches) {
 408                VG_(free)(patt);
 409                return False;
 410             }
 411          }
 412          VG_(free)(patt);
 413       }
 414    }
 415
 416    // --trace-children=yes, and this particular executable isn't
 417    // excluded
 418    return True;
 419 }
 420
 421
 422 /*--------------------------------------------------------------------*/
 423 /*--- end                                                          ---*/
 424 /*--------------------------------------------------------------------*/