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-2010 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 Bool VG_(clo_db_attach) = False;
50 Char* VG_(clo_db_command) = GDB_PATH " -nw %f %p";
51 Int VG_(clo_gen_suppressions) = 0;
52 Int VG_(clo_sanity_level) = 1;
53 Int VG_(clo_verbosity) = 1;
54 Bool VG_(clo_stats) = False;
55 Bool VG_(clo_xml) = False;
56 HChar* VG_(clo_xml_user_comment) = NULL;
57 Bool VG_(clo_demangle) = True;
58 Bool VG_(clo_trace_children) = False;
59 HChar* VG_(clo_trace_children_skip) = NULL;
60 Bool VG_(clo_child_silent_after_fork) = False;
61 Char* VG_(clo_log_fname_expanded) = NULL;
62 Char* VG_(clo_xml_fname_expanded) = NULL;
63 Bool VG_(clo_time_stamp) = False;
64 Int VG_(clo_input_fd) = 0; /* stdin */
65 Int VG_(clo_n_suppressions) = 0;
66 Char* VG_(clo_suppressions)[VG_CLO_MAX_SFILES];
67 Int VG_(clo_n_fullpath_after) = 0;
68 Char* VG_(clo_fullpath_after)[VG_CLO_MAX_FULLPATH_AFTER];
69 UChar VG_(clo_trace_flags) = 0; // 00000000b
70 UChar VG_(clo_profile_flags) = 0; // 00000000b
71 Int VG_(clo_trace_notbelow) = 999999999;
72 Bool VG_(clo_trace_syscalls) = False;
73 Bool VG_(clo_trace_signals) = False;
74 Bool VG_(clo_trace_symtab) = False;
75 HChar* VG_(clo_trace_symtab_patt) = "*";
76 Bool VG_(clo_trace_cfi) = False;
77 Bool VG_(clo_debug_dump_syms) = False;
78 Bool VG_(clo_debug_dump_line) = False;
79 Bool VG_(clo_debug_dump_frames) = False;
80 Bool VG_(clo_trace_redir) = False;
81 Bool VG_(clo_trace_sched) = False;
82 Bool VG_(clo_profile_heap) = False;
83 Int VG_(clo_dump_error) = 0;
84 Int VG_(clo_backtrace_size) = 12;
85 Char* VG_(clo_sim_hints) = NULL;
86 Bool VG_(clo_sym_offsets) = False;
87 Bool VG_(clo_read_var_info) = False;
88 Int VG_(clo_n_req_tsyms) = 0;
89 HChar* VG_(clo_req_tsyms)[VG_CLO_MAX_REQ_TSYMS];
90 HChar* VG_(clo_require_text_symbol) = NULL;
91 Bool VG_(clo_run_libc_freeres) = True;
92 Bool VG_(clo_track_fds) = False;
93 Bool VG_(clo_show_below_main)= False;
94 Bool VG_(clo_show_emwarns) = False;
95 Word VG_(clo_max_stackframe) = 2000000;
96 Word VG_(clo_main_stacksize) = 0; /* use client's rlimit.stack */
97 Bool VG_(clo_wait_for_gdb) = False;
98 VgSmc VG_(clo_smc_check) = Vg_SmcStack;
99 HChar* VG_(clo_kernel_variant) = NULL;
100 Bool VG_(clo_dsymutil) = False;
101 Char* VG_(clo_memfs_malloc_path) = NULL;
102 Int VG_(clo_memfs_page_size) = 2048; /* 2M */
103
104
105 /*====================================================================*/
106 /*=== File expansion ===*/
107 /*====================================================================*/
108
109 // Copies the string, prepending it with the startup working directory, and
110 // expanding %p and %q entries. Returns a new, malloc'd string.
VG_(expand_file_name)111 Char* VG_(expand_file_name)(Char* option_name, Char* format)
112 {
113 static Char base_dir[VKI_PATH_MAX];
114 Int len, i = 0, j = 0;
115 Char* out;
116
117 Bool ok = VG_(get_startup_wd)(base_dir, VKI_PATH_MAX);
118 tl_assert(ok);
119
120 if (VG_STREQ(format, "")) {
121 // Empty name, bad.
122 VG_(fmsg)("%s: filename is empty", option_name);
123 goto bad;
124 }
125
126 // If 'format' starts with a '~', abort -- the user probably expected the
127 // shell to expand but it didn't (see bug 195268 for details). This means
128 // that we don't allow a legitimate filename beginning with '~' but that
129 // seems very unlikely.
130 if (format[0] == '~') {
131 VG_(fmsg)(
132 "%s: filename begins with '~'\n"
133 "You probably expected the shell to expand the '~', but it\n"
134 "didn't. The rules for '~'-expansion vary from shell to shell.\n"
135 "You might have more luck using $HOME instead.\n",
136 option_name
137 );
138 goto bad;
139 }
140
141 // If 'format' starts with a '/', do not prefix with startup dir.
142 if (format[0] != '/') {
143 j += VG_(strlen)(base_dir);
144 }
145
146 // The 10 is slop, it should be enough in most cases.
147 len = j + VG_(strlen)(format) + 10;
148 out = VG_(malloc)( "options.efn.1", len );
149 if (format[0] != '/') {
150 VG_(strcpy)(out, base_dir);
151 out[j++] = '/';
152 }
153
154 #define ENSURE_THIS_MUCH_SPACE(x) \
155 if (j + x >= len) { \
156 len += (10 + x); \
157 out = VG_(realloc)("options.efn.2(multiple)", out, len); \
158 }
159
160 while (format[i]) {
161 if (format[i] != '%') {
162 ENSURE_THIS_MUCH_SPACE(1);
163 out[j++] = format[i++];
164
165 } else {
166 // We saw a '%'. What's next...
167 i++;
168 if ('%' == format[i]) {
169 // Replace '%%' with '%'.
170 ENSURE_THIS_MUCH_SPACE(1);
171 out[j++] = format[i++];
172 }
173 else if ('p' == format[i]) {
174 // Print the PID. Assume that it's not longer than 10 chars --
175 // reasonable since 'pid' is an Int (ie. 32 bits).
176 Int pid = VG_(getpid)();
177 ENSURE_THIS_MUCH_SPACE(10);
178 j += VG_(sprintf)(&out[j], "%d", pid);
179 i++;
180 }
181 else if ('q' == format[i]) {
182 i++;
183 if ('{' == format[i]) {
184 // Get the env var name, print its contents.
185 Char* qualname;
186 Char* qual;
187 i++;
188 qualname = &format[i];
189 while (True) {
190 if (0 == format[i]) {
191 VG_(fmsg)("%s: malformed %%q specifier\n", option_name);
192 goto bad;
193 } else if ('}' == format[i]) {
194 // Temporarily replace the '}' with NUL to extract var
195 // name.
196 format[i] = 0;
197 qual = VG_(getenv)(qualname);
198 if (NULL == qual) {
199 VG_(fmsg)("%s: environment variable %s is not set\n",
200 option_name, qualname);
201 format[i] = '}'; // Put the '}' back.
202 goto bad;
203 }
204 format[i] = '}'; // Put the '}' back.
205 i++;
206 break;
207 }
208 i++;
209 }
210 ENSURE_THIS_MUCH_SPACE(VG_(strlen)(qual));
211 j += VG_(sprintf)(&out[j], "%s", qual);
212 } else {
213 VG_(fmsg)("%s: expected '{' after '%%q'\n", option_name);
214 goto bad;
215 }
216 }
217 else {
218 // Something else, abort.
219 VG_(fmsg)("%s: expected 'p' or 'q' or '%%' after '%%'\n",
220 option_name);
221 goto bad;
222 }
223 }
224 }
225 ENSURE_THIS_MUCH_SPACE(1);
226 out[j++] = 0;
227
228 return out;
229
230 bad: {
231 Char* opt = // 2: 1 for the '=', 1 for the NUL.
232 VG_(malloc)( "options.efn.3",
233 VG_(strlen)(option_name) + VG_(strlen)(format) + 2 );
234 VG_(strcpy)(opt, option_name);
235 VG_(strcat)(opt, "=");
236 VG_(strcat)(opt, format);
237 VG_(fmsg_bad_option)(opt, "");
238 }
239 }
240
241 /*====================================================================*/
242 /*=== --trace-children= support ===*/
243 /*====================================================================*/
244
consume_commas(HChar const * c)245 static HChar const* consume_commas ( HChar const* c ) {
246 while (*c && *c == ',') {
247 ++c;
248 }
249 return c;
250 }
251
consume_field(HChar const * c)252 static HChar const* consume_field ( HChar const* c ) {
253 while (*c && *c != ',') {
254 ++c;
255 }
256 return c;
257 }
258
259 /* Should we trace into this child executable (across execve etc) ?
260 This involves considering --trace-children=, --trace-children-skip=
261 and the name of the executable. */
VG_(should_we_trace_this_child)262 Bool VG_(should_we_trace_this_child) ( HChar* child_exe_name )
263 {
264 // child_exe_name is pulled out of the guest's space. We
265 // should be at least marginally cautious with it, lest it
266 // explode or burst into flames unexpectedly.
267 if (child_exe_name == NULL || VG_(strlen)(child_exe_name) == 0)
268 return VG_(clo_trace_children); // we know narfink
269
270 // the main logic
271 // If --trace-children=no, the answer is simply NO.
272 if (! VG_(clo_trace_children))
273 return False;
274
275 // otherwise, return True, unless the exe name matches any of the
276 // patterns specified by --trace-children-skip=.
277 if (VG_(clo_trace_children_skip)) {
278 HChar const* last = VG_(clo_trace_children_skip);
279 HChar const* name = (HChar const*)child_exe_name;
280 while (*last) {
281 Bool matches;
282 HChar* patt;
283 HChar const* first = consume_commas(last);
284 last = consume_field(first);
285 if (first == last)
286 break;
287 vg_assert(last > first);
288 /* copy the candidate string into a temporary malloc'd block
289 so we can use VG_(string_match) on it. */
290 patt = VG_(calloc)("m_options.swttc.1", last - first + 1, 1);
291 VG_(memcpy)(patt, first, last - first);
292 vg_assert(patt[last-first] == 0);
293 matches = VG_(string_match)(patt, name);
294 VG_(free)(patt);
295 if (matches)
296 return False;
297 }
298 }
299
300 // --trace-children=yes, and this particular executable isn't
301 // excluded
302 return True;
303 }
304
305
306 /*--------------------------------------------------------------------*/
307 /*--- end ---*/
308 /*--------------------------------------------------------------------*/
309