2 * Copyright (c) 2016 Dmitry V. Levin <ldv@altlinux.org>
3 * Copyright (c) 2016-2018 The strace developers.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 #include "number_set.h"
36 struct number_set *read_set;
37 struct number_set *write_set;
38 struct number_set *signal_set;
40 static struct number_set *abbrev_set;
41 static struct number_set *inject_set;
42 static struct number_set *raw_set;
43 static struct number_set *trace_set;
44 static struct number_set *verbose_set;
47 sigstr_to_uint(const char *s)
49 if (*s >= '0' && *s <= '9')
50 return string_to_uint_upto(s, 255);
52 if (strncasecmp(s, "SIG", 3) == 0)
55 for (int i = 0; i <= 255; ++i) {
56 const char *name = signame(i);
58 if (strncasecmp(name, "SIG", 3) != 0)
63 if (strcasecmp(name, s) != 0)
73 find_errno_by_name(const char *name)
75 for (unsigned int i = 1; i < nerrnos; ++i) {
76 if (errnoent[i] && (strcasecmp(name, errnoent[i]) == 0))
84 parse_delay_token(const char *input, struct inject_opts *fopts, bool isenter)
86 unsigned flag = isenter ? INJECT_F_DELAY_ENTER : INJECT_F_DELAY_EXIT;
88 if (fopts->data.flags & flag) /* duplicate */
90 long long intval = string_to_ulonglong(input);
91 if (intval < 0) /* couldn't parse */
94 if (fopts->data.delay_idx == (uint16_t) -1)
95 fopts->data.delay_idx = alloc_delay_data();
96 /* populate .ts_enter or .ts_exit */
97 fill_delay_data(fopts->data.delay_idx, intval, isenter);
98 fopts->data.flags |= flag;
104 parse_inject_token(const char *const token, struct inject_opts *const fopts,
105 const bool fault_tokens_only)
110 if ((val = STR_STRIP_PREFIX(token, "when=")) != token) {
118 intval = string_to_uint_ex(val, &end, 0xffff, "+");
122 fopts->first = intval;
128 intval = string_to_uint_upto(val, 0xffff);
131 fopts->step = intval;
140 } else if ((val = STR_STRIP_PREFIX(token, "error=")) != token) {
141 if (fopts->data.flags & (INJECT_F_ERROR | INJECT_F_RETVAL))
143 intval = string_to_uint_upto(val, MAX_ERRNO_VALUE);
145 intval = find_errno_by_name(val);
148 fopts->data.rval_idx = retval_new(intval);
149 fopts->data.flags |= INJECT_F_ERROR;
150 } else if (!fault_tokens_only
151 && (val = STR_STRIP_PREFIX(token, "retval=")) != token) {
153 if (fopts->data.flags & (INJECT_F_ERROR | INJECT_F_RETVAL))
158 unsigned long long ullval = strtoull(val, &endp, 0);
159 if (endp == val || *endp || (kernel_ulong_t) ullval != ullval
160 || ((ullval == 0 || ullval == ULLONG_MAX) && errno))
163 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
164 bool inadvertent_fault_injection = false;
167 #if !HAVE_ARCH_DEDICATED_ERR_REG
168 if ((kernel_long_t) ullval < 0
169 && (kernel_long_t) ullval >= -MAX_ERRNO_VALUE) {
170 # if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
171 inadvertent_fault_injection = true;
173 error_msg("Inadvertent injection of error %" PRI_kld
174 " is possible for retval=%llu",
175 -(kernel_long_t) ullval, ullval);
177 # if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
178 else if ((int) ullval < 0 && (int) ullval >= -MAX_ERRNO_VALUE) {
179 inadvertent_fault_injection = true;
180 error_msg("Inadvertent injection of error %d is"
181 " possible in compat personality for"
183 -(int) ullval, ullval);
188 #if ANY_WORDSIZE_LESS_THAN_KERNEL_LONG
189 if (!inadvertent_fault_injection
190 && (unsigned int) ullval != ullval) {
191 error_msg("Injected return value %llu will be"
192 " clipped to %u in compat personality",
193 ullval, (unsigned int) ullval);
197 fopts->data.rval_idx = retval_new(ullval);
198 fopts->data.flags |= INJECT_F_RETVAL;
199 } else if (!fault_tokens_only
200 && (val = STR_STRIP_PREFIX(token, "signal=")) != token) {
201 if (fopts->data.flags & INJECT_F_SIGNAL)
203 intval = sigstr_to_uint(val);
204 if (intval < 1 || intval > NSIG_BYTES * 8)
206 fopts->data.signo = intval;
207 fopts->data.flags |= INJECT_F_SIGNAL;
208 } else if (!fault_tokens_only
209 && (val = STR_STRIP_PREFIX(token, "delay_enter=")) != token) {
210 if (!parse_delay_token(val, fopts, true))
212 } else if (!fault_tokens_only
213 && (val = STR_STRIP_PREFIX(token, "delay_exit=")) != token) {
214 if (!parse_delay_token(val, fopts, false))
224 parse_inject_expression(char *const str,
225 struct inject_opts *const fopts,
226 const bool fault_tokens_only)
228 if (str[0] == '\0' || str[0] == ':')
231 char *saveptr = NULL;
232 const char *name = strtok_r(str, ":", &saveptr);
235 while ((token = strtok_r(NULL, ":", &saveptr))) {
236 if (!parse_inject_token(token, fopts, fault_tokens_only))
244 qualify_read(const char *const str)
247 read_set = alloc_number_set_array(1);
248 qualify_tokens(str, read_set, string_to_uint, "descriptor");
252 qualify_write(const char *const str)
255 write_set = alloc_number_set_array(1);
256 qualify_tokens(str, write_set, string_to_uint, "descriptor");
260 qualify_signals(const char *const str)
263 signal_set = alloc_number_set_array(1);
264 qualify_tokens(str, signal_set, sigstr_to_uint, "signal");
268 qualify_trace(const char *const str)
271 trace_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
272 qualify_syscall_tokens(str, trace_set);
276 qualify_abbrev(const char *const str)
279 abbrev_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
280 qualify_syscall_tokens(str, abbrev_set);
284 qualify_verbose(const char *const str)
287 verbose_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
288 qualify_syscall_tokens(str, verbose_set);
292 qualify_raw(const char *const str)
295 raw_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
296 qualify_syscall_tokens(str, raw_set);
300 qualify_inject_common(const char *const str,
301 const bool fault_tokens_only,
302 const char *const description)
304 struct inject_opts opts = {
311 char *copy = xstrdup(str);
313 parse_inject_expression(copy, &opts, fault_tokens_only);
315 error_msg_and_die("invalid %s '%s'", description, str);
317 struct number_set *tmp_set =
318 alloc_number_set_array(SUPPORTED_PERSONALITIES);
319 qualify_syscall_tokens(name, tmp_set);
323 /* If neither of retval, error, signal or delay is specified, then ... */
324 if (!opts.data.flags) {
325 if (fault_tokens_only) {
326 /* in fault= syntax the default error code is ENOSYS. */
327 opts.data.rval_idx = retval_new(ENOSYS);
328 opts.data.flags |= INJECT_F_ERROR;
330 /* in inject= syntax this is not allowed. */
331 error_msg_and_die("invalid %s '%s'", description, str);
336 * Initialize inject_vec according to tmp_set.
337 * Merge tmp_set into inject_set.
339 for (unsigned int p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
340 if (number_set_array_is_empty(tmp_set, p))
345 alloc_number_set_array(SUPPORTED_PERSONALITIES);
347 if (!inject_vec[p]) {
348 inject_vec[p] = xcalloc(nsyscall_vec[p],
349 sizeof(*inject_vec[p]));
352 for (unsigned int i = 0; i < nsyscall_vec[p]; ++i) {
353 if (is_number_in_set_array(i, tmp_set, p)) {
354 add_number_to_set_array(i, inject_set, p);
355 inject_vec[p][i] = opts;
360 free_number_set_array(tmp_set, SUPPORTED_PERSONALITIES);
364 qualify_fault(const char *const str)
366 qualify_inject_common(str, true, "fault argument");
370 qualify_inject(const char *const str)
372 qualify_inject_common(str, false, "inject argument");
375 static const struct qual_options {
377 void (*qualify)(const char *);
379 { "trace", qualify_trace },
380 { "t", qualify_trace },
381 { "abbrev", qualify_abbrev },
382 { "a", qualify_abbrev },
383 { "verbose", qualify_verbose },
384 { "v", qualify_verbose },
385 { "raw", qualify_raw },
386 { "x", qualify_raw },
387 { "signal", qualify_signals },
388 { "signals", qualify_signals },
389 { "s", qualify_signals },
390 { "read", qualify_read },
391 { "reads", qualify_read },
392 { "r", qualify_read },
393 { "write", qualify_write },
394 { "writes", qualify_write },
395 { "w", qualify_write },
396 { "fault", qualify_fault },
397 { "inject", qualify_inject },
401 qualify(const char *str)
403 const struct qual_options *opt = qual_options;
405 for (unsigned int i = 0; i < ARRAY_SIZE(qual_options); ++i) {
406 const char *name = qual_options[i].name;
407 const size_t len = strlen(name);
408 const char *val = str_strip_prefix_len(str, name, len);
410 if (val == str || *val != '=')
413 opt = &qual_options[i];
421 qual_flags(const unsigned int scno)
423 return (is_number_in_set_array(scno, trace_set, current_personality)
425 | (is_number_in_set_array(scno, abbrev_set, current_personality)
427 | (is_number_in_set_array(scno, verbose_set, current_personality)
429 | (is_number_in_set_array(scno, raw_set, current_personality)
431 | (is_number_in_set_array(scno, inject_set, current_personality)