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-2013 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
42 // See pub_{core,tool}_options.h for explanations of all these.
43
44
45 /* Define, and set defaults. */
46 VexControl VG_(clo_vex_control);
47 Bool VG_(clo_error_limit) = True;
48 Int VG_(clo_error_exitcode) = 0;
49
50 #if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android) \
51 || defined(VGPV_mips32_linux_android)
52 VgVgdb VG_(clo_vgdb) = Vg_VgdbNo; // currently disabled on Android
53 #else
54 VgVgdb VG_(clo_vgdb) = Vg_VgdbYes;
55 #endif
56 Int VG_(clo_vgdb_poll) = 5000;
57 Int VG_(clo_vgdb_error) = 999999999;
58 UInt VG_(clo_vgdb_stop_at) = 0;
59 const HChar *VG_(clo_vgdb_prefix) = NULL;
60 const HChar *VG_(arg_vgdb_prefix) = NULL;
61 Bool VG_(clo_vgdb_shadow_registers) = False;
62
63 Bool VG_(clo_db_attach) = False;
64 const HChar* VG_(clo_db_command) = GDB_PATH " -nw %f %p";
65 Int VG_(clo_gen_suppressions) = 0;
66 Int VG_(clo_sanity_level) = 1;
67 Int VG_(clo_verbosity) = 1;
68 Bool VG_(clo_stats) = False;
69 Bool VG_(clo_xml) = False;
70 const HChar* VG_(clo_xml_user_comment) = NULL;
71 Bool VG_(clo_demangle) = True;
72 const HChar* VG_(clo_soname_synonyms) = NULL;
73 Bool VG_(clo_trace_children) = False;
74 const HChar* VG_(clo_trace_children_skip) = NULL;
75 const HChar* VG_(clo_trace_children_skip_by_arg) = NULL;
76 Bool VG_(clo_child_silent_after_fork) = False;
77 HChar* VG_(clo_log_fname_expanded) = NULL;
78 HChar* VG_(clo_xml_fname_expanded) = NULL;
79 Bool VG_(clo_time_stamp) = False;
80 Int VG_(clo_input_fd) = 0; /* stdin */
81 Int VG_(clo_n_suppressions) = 0;
82 const HChar* VG_(clo_suppressions)[VG_CLO_MAX_SFILES];
83 Int VG_(clo_n_fullpath_after) = 0;
84 const HChar* VG_(clo_fullpath_after)[VG_CLO_MAX_FULLPATH_AFTER];
85 const HChar* VG_(clo_extra_debuginfo_path) = NULL;
86 const HChar* VG_(clo_debuginfo_server) = NULL;
87 Bool VG_(clo_allow_mismatched_debuginfo) = False;
88 UChar VG_(clo_trace_flags) = 0; // 00000000b
89 Bool VG_(clo_profyle_sbs) = False;
90 UChar VG_(clo_profyle_flags) = 0; // 00000000b
91 ULong VG_(clo_profyle_interval) = 0;
92 Int VG_(clo_trace_notbelow) = -1; // unspecified
93 Int VG_(clo_trace_notabove) = -1; // unspecified
94 Bool VG_(clo_trace_syscalls) = False;
95 Bool VG_(clo_trace_signals) = False;
96 Bool VG_(clo_trace_symtab) = False;
97 const HChar* VG_(clo_trace_symtab_patt) = "*";
98 Bool VG_(clo_trace_cfi) = False;
99 Bool VG_(clo_debug_dump_syms) = False;
100 Bool VG_(clo_debug_dump_line) = False;
101 Bool VG_(clo_debug_dump_frames) = False;
102 Bool VG_(clo_trace_redir) = False;
103 enum FairSchedType
104 VG_(clo_fair_sched) = disable_fair_sched;
105 Bool VG_(clo_trace_sched) = False;
106 Bool VG_(clo_profile_heap) = False;
107 Int VG_(clo_core_redzone_size) = CORE_REDZONE_DEFAULT_SZB;
108 // A value != -1 overrides the tool-specific value
109 // VG_(needs_malloc_replacement).tool_client_redzone_szB
110 Int VG_(clo_redzone_size) = -1;
111 Int VG_(clo_dump_error) = 0;
112 Int VG_(clo_backtrace_size) = 12;
113 Int VG_(clo_merge_recursive_frames) = 0; // default value: no merge
114 const HChar* VG_(clo_sim_hints) = NULL;
115 Bool VG_(clo_sym_offsets) = False;
116 Bool VG_(clo_read_var_info) = False;
117 Int VG_(clo_n_req_tsyms) = 0;
118 const HChar* VG_(clo_req_tsyms)[VG_CLO_MAX_REQ_TSYMS];
119 HChar* VG_(clo_require_text_symbol) = NULL;
120 Bool VG_(clo_run_libc_freeres) = True;
121 Bool VG_(clo_track_fds) = False;
122 Bool VG_(clo_show_below_main)= False;
123 Bool VG_(clo_show_emwarns) = False;
124 Word VG_(clo_max_stackframe) = 2000000;
125 Word VG_(clo_main_stacksize) = 0; /* use client's rlimit.stack */
126 Bool VG_(clo_wait_for_gdb) = False;
127 VgSmc VG_(clo_smc_check) = Vg_SmcStack;
128 const HChar* VG_(clo_kernel_variant) = NULL;
129 Bool VG_(clo_dsymutil) = False;
130 Bool VG_(clo_sigill_diag) = True;
131 UInt VG_(clo_unw_stack_scan_thresh) = 0; /* disabled by default */
132 UInt VG_(clo_unw_stack_scan_frames) = 5;
133
134
135 /*====================================================================*/
136 /*=== File expansion ===*/
137 /*====================================================================*/
138
139 // Copies the string, prepending it with the startup working directory, and
140 // expanding %p and %q entries. Returns a new, malloc'd string.
VG_(expand_file_name)141 HChar* VG_(expand_file_name)(const HChar* option_name, const HChar* format)
142 {
143 static HChar base_dir[VKI_PATH_MAX];
144 Int len, i = 0, j = 0;
145 HChar* out;
146
147 Bool ok = VG_(get_startup_wd)(base_dir, VKI_PATH_MAX);
148 tl_assert(ok);
149
150 if (VG_STREQ(format, "")) {
151 // Empty name, bad.
152 VG_(fmsg)("%s: filename is empty", option_name);
153 goto bad;
154 }
155
156 // If 'format' starts with a '~', abort -- the user probably expected the
157 // shell to expand but it didn't (see bug 195268 for details). This means
158 // that we don't allow a legitimate filename beginning with '~' but that
159 // seems very unlikely.
160 if (format[0] == '~') {
161 VG_(fmsg)(
162 "%s: filename begins with '~'\n"
163 "You probably expected the shell to expand the '~', but it\n"
164 "didn't. The rules for '~'-expansion vary from shell to shell.\n"
165 "You might have more luck using $HOME instead.\n",
166 option_name
167 );
168 goto bad;
169 }
170
171 len = VG_(strlen)(format) + 1;
172 out = VG_(malloc)( "options.efn.1", len );
173
174 #define ENSURE_THIS_MUCH_SPACE(x) \
175 if (j + x >= len) { \
176 len += (10 + x); \
177 out = VG_(realloc)("options.efn.2(multiple)", out, len); \
178 }
179
180 while (format[i]) {
181 if (format[i] != '%') {
182 ENSURE_THIS_MUCH_SPACE(1);
183 out[j++] = format[i++];
184
185 } else {
186 // We saw a '%'. What's next...
187 i++;
188 if ('%' == format[i]) {
189 // Replace '%%' with '%'.
190 ENSURE_THIS_MUCH_SPACE(1);
191 out[j++] = format[i++];
192 }
193 else if ('p' == format[i]) {
194 // Print the PID. Assume that it's not longer than 10 chars --
195 // reasonable since 'pid' is an Int (ie. 32 bits).
196 Int pid = VG_(getpid)();
197 ENSURE_THIS_MUCH_SPACE(10);
198 j += VG_(sprintf)(&out[j], "%d", pid);
199 i++;
200 }
201 else if ('q' == format[i]) {
202 i++;
203 if ('{' == format[i]) {
204 // Get the env var name, print its contents.
205 const HChar* qualname;
206 HChar* qual;
207 i++;
208 qualname = &format[i];
209 while (True) {
210 if (0 == format[i]) {
211 VG_(fmsg)("%s: malformed %%q specifier\n", option_name);
212 goto bad;
213 } else if ('}' == format[i]) {
214 // Temporarily replace the '}' with NUL to extract var
215 // name.
216 // FIXME: this is not safe as FORMAT is sometimes a
217 // string literal which may reside in read-only memory
218 ((HChar *)format)[i] = 0;
219 qual = VG_(getenv)(qualname);
220 if (NULL == qual) {
221 VG_(fmsg)("%s: environment variable %s is not set\n",
222 option_name, qualname);
223 // FIXME: this is not safe as FORMAT is sometimes a
224 // string literal which may reside in read-only memory
225 ((HChar *)format)[i] = '}'; // Put the '}' back.
226 goto bad;
227 }
228 // FIXME: this is not safe as FORMAT is sometimes a
229 // string literal which may reside in read-only memory
230 ((HChar *)format)[i] = '}'; // Put the '}' back.
231 i++;
232 break;
233 }
234 i++;
235 }
236 ENSURE_THIS_MUCH_SPACE(VG_(strlen)(qual));
237 j += VG_(sprintf)(&out[j], "%s", qual);
238 } else {
239 VG_(fmsg)("%s: expected '{' after '%%q'\n", option_name);
240 goto bad;
241 }
242 }
243 else {
244 // Something else, abort.
245 VG_(fmsg)("%s: expected 'p' or 'q' or '%%' after '%%'\n",
246 option_name);
247 goto bad;
248 }
249 }
250 }
251 ENSURE_THIS_MUCH_SPACE(1);
252 out[j++] = 0;
253
254 // If 'out' is not an absolute path name, prefix it with the startup dir.
255 if (out[0] != '/') {
256 len = VG_(strlen)(base_dir) + 1 + VG_(strlen)(out) + 1;
257
258 HChar *absout = VG_(malloc)("options.efn.4", len);
259 VG_(strcpy)(absout, base_dir);
260 VG_(strcat)(absout, "/");
261 VG_(strcat)(absout, out);
262 VG_(free)(out);
263 out = absout;
264 }
265
266 return out;
267
268 bad: {
269 HChar* opt = // 2: 1 for the '=', 1 for the NUL.
270 VG_(malloc)( "options.efn.3",
271 VG_(strlen)(option_name) + VG_(strlen)(format) + 2 );
272 VG_(strcpy)(opt, option_name);
273 VG_(strcat)(opt, "=");
274 VG_(strcat)(opt, format);
275 VG_(fmsg_bad_option)(opt, "");
276 }
277 }
278
279 /*====================================================================*/
280 /*=== --trace-children= support ===*/
281 /*====================================================================*/
282
consume_commas(HChar const * c)283 static HChar const* consume_commas ( HChar const* c ) {
284 while (*c && *c == ',') {
285 ++c;
286 }
287 return c;
288 }
289
consume_field(HChar const * c)290 static HChar const* consume_field ( HChar const* c ) {
291 while (*c && *c != ',') {
292 ++c;
293 }
294 return c;
295 }
296
297 /* Should we trace into this child executable (across execve etc) ?
298 This involves considering --trace-children=,
299 --trace-children-skip=, --trace-children-skip-by-arg=, and the name
300 of the executable. 'child_argv' must not include the name of the
301 executable itself; iow child_argv[0] must be the first arg, if any,
302 for the child. */
VG_(should_we_trace_this_child)303 Bool VG_(should_we_trace_this_child) ( HChar* child_exe_name,
304 HChar** child_argv )
305 {
306 // child_exe_name is pulled out of the guest's space. We
307 // should be at least marginally cautious with it, lest it
308 // explode or burst into flames unexpectedly.
309 if (child_exe_name == NULL || VG_(strlen)(child_exe_name) == 0)
310 return VG_(clo_trace_children); // we know narfink
311
312 // If --trace-children=no, the answer is simply NO.
313 if (! VG_(clo_trace_children))
314 return False;
315
316 // Otherwise, look for other reasons to say NO. First,
317 // see if the exe name matches any of the patterns specified
318 // by --trace-children-skip=.
319 if (VG_(clo_trace_children_skip)) {
320 HChar const* last = VG_(clo_trace_children_skip);
321 HChar const* name = child_exe_name;
322 while (*last) {
323 Bool matches;
324 HChar* patt;
325 HChar const* first = consume_commas(last);
326 last = consume_field(first);
327 if (first == last)
328 break;
329 vg_assert(last > first);
330 /* copy the candidate string into a temporary malloc'd block
331 so we can use VG_(string_match) on it. */
332 patt = VG_(calloc)("m_options.swttc.1", last - first + 1, 1);
333 VG_(memcpy)(patt, first, last - first);
334 vg_assert(patt[last-first] == 0);
335 matches = VG_(string_match)(patt, name);
336 VG_(free)(patt);
337 if (matches)
338 return False;
339 }
340 }
341
342 // Check if any of the args match any of the patterns specified
343 // by --trace-children-skip-by-arg=.
344 if (VG_(clo_trace_children_skip_by_arg) && child_argv != NULL) {
345 HChar const* last = VG_(clo_trace_children_skip_by_arg);
346 while (*last) {
347 Int i;
348 Bool matches;
349 HChar* patt;
350 HChar const* first = consume_commas(last);
351 last = consume_field(first);
352 if (first == last)
353 break;
354 vg_assert(last > first);
355 /* copy the candidate string into a temporary malloc'd block
356 so we can use VG_(string_match) on it. */
357 patt = VG_(calloc)("m_options.swttc.1", last - first + 1, 1);
358 VG_(memcpy)(patt, first, last - first);
359 vg_assert(patt[last-first] == 0);
360 for (i = 0; child_argv[i]; i++) {
361 matches = VG_(string_match)(patt, child_argv[i]);
362 if (matches) {
363 VG_(free)(patt);
364 return False;
365 }
366 }
367 VG_(free)(patt);
368 }
369 }
370
371 // --trace-children=yes, and this particular executable isn't
372 // excluded
373 return True;
374 }
375
376
377 /*--------------------------------------------------------------------*/
378 /*--- end ---*/
379 /*--------------------------------------------------------------------*/
380