This change introduces new filtering architecture primitives: filter,
filter_action and bool_expression. Filtering is now done after decoding of
syscall and tcp->qual_flg stores filtering results.
* basic_actions.c: New file.
* filter_action.c: Likewise.
* filter_expression.c: Likewise.
* filter.c: Likewise.
* basic_filters.c (qualify_tokens): Remove 'handle_inversion' label,
do not clear the set.
(qualify_syscall_tokens): Likewise. Remove "name"
argument(assume "system call").
(parse_syscall_filter, parse_fd_filter, parse_path_filter,
run_syscall_filter, run_fd_filter, run_path_filter,
free_syscall_filter, free_fd_filter, free_path_filter): New functions.
* defs.h (struct inject_opts): Add init flag.
(qual_flags): Remove old declaration.
(filter_syscall, filtering_parsing_finish): Add new declarations.
* filter.h: Add new declarations.
(qualify_syscall_tokens): Change declaration.
* filter_qualify.c (read_set, write_set, abbrev_set, inject_set, raw_set,
trace_set, verbose_set): Remove set variables.
(parse_inject_expression): Remove function.
(parse_inject_common_args): New function.
(qualify_signals): Clear set before use.
(qualify_read, qualify_write, qualify_trace, qualify_abbrev,
qualify_verbose, qualify_raw): Use new filtering API.
(qualify_inject_common): Likewise. Use parse_inject_common_args for parsing.
(qualify_fault, qualify_inject): Remove "argument" from description
argument of qualify_inject_common.
(qual_flags): Remove function.
* number_set.h (read_set, write_set): Remove set declarations.
* pathtrace.c (storepath): Duplicate paths.
* strace.c (init): Call filtering_parse_finish after command line parsing.
(trace_syscall): Add filtering after syscall decoding.
(droptcb): Don't free inject_vec for empty personalities.
* syscall.c (decode_socket_subcall): Remove qual_flags from decoder.
(decode_ipc_subcall): Likewise.
(decode_mips_subcall): Likewise.
(get_scno): Likewise.
(inject_vec, tamper_with_syscall_entering): Remove inject_vec support code.
(dumpio): Check dump_read, dump_write macros instead of global sets.
---
Makefile.am | 4 +
basic_actions.c | 130 ++++++++++++++++++++++++
basic_filters.c | 111 ++++++++++++++++++---
defs.h | 4 +-
filter.c | 144 +++++++++++++++++++++++++++
filter.h | 34 ++++++-
filter_action.c | 240 ++++++++++++++++++++++++++++++++++++++++++++
filter_expression.c | 281 ++++++++++++++++++++++++++++++++++++++++++++++++++++
filter_qualify.c | 196 +++++++++++++++---------------------
number_set.h | 2 -
pathtrace.c | 2 +-
strace.c | 6 +-
syscall.c | 20 +---
13 files changed, 1018 insertions(+), 156 deletions(-)
create mode 100644 basic_actions.c
create mode 100644 filter.c
create mode 100644 filter_action.c
create mode 100644 filter_expression.c
diff --git a/Makefile.am b/Makefile.am
index b3afc7c5..b928eb28 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -86,6 +86,7 @@ strace_SOURCES = \
affinity.c \
aio.c \
alpha.c \
+ basic_actions.c \
basic_filters.c \
bind.c \
bjm.c \
@@ -133,7 +134,10 @@ strace_SOURCES = \
fetch_struct_statfs.c \
file_handle.c \
file_ioctl.c \
+ filter_action.c \
+ filter_expression.c \
filter_qualify.c \
+ filter.c \
filter.h \
flock.c \
flock.h \
diff --git a/basic_actions.c b/basic_actions.c
new file mode 100644
index 00000000..740a9d5e
--- /dev/null
+++ b/basic_actions.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikola...@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include "filter.h"
+
+bool
+is_traced(struct tcb *tcp)
+{
+ return traced(tcp);
+}
+
+bool
+not_injected(struct tcb *tcp)
+{
+ return !inject(tcp);
+}
+
+void *
+parse_null(const char *str)
+{
+ return NULL;
+}
+
+void
+apply_trace(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_TRACE;
+}
+
+void
+apply_inject(struct tcb *tcp, void *_priv_data)
+{
+ struct inject_opts *opts = _priv_data;
+
+ tcp->qual_flg |= QUAL_INJECT;
+ if (!tcp->inject_vec[current_personality])
+ tcp->inject_vec[current_personality] =
+ xcalloc(nsyscalls, sizeof(struct inject_opts));
+ if (scno_in_range(tcp->scno)
+ && !tcp->inject_vec[current_personality][tcp->scno].init)
+ tcp->inject_vec[current_personality][tcp->scno] = *opts;
+}
+
+static void *
+parse_inject_common(const char *str, bool fault_tokens_only,
+ const char *description)
+{
+ struct inject_opts *opts = xmalloc(sizeof(struct inject_opts));
+ char *buf = xstrdup(str);
+
+ parse_inject_common_args(buf, opts, fault_tokens_only, false);
+ if (!opts->init)
+ error_msg_and_die("invalid %s argument '%s'",
+ description, str ? str : "");
+ free(buf);
+ return opts;
+}
+
+void *
+parse_inject(const char *str)
+{
+ return parse_inject_common(str, false, "inject");
+}
+
+void
+apply_fault(struct tcb *tcp, void *_priv_data)
+{
+ apply_inject(tcp, _priv_data);
+}
+
+void *
+parse_fault(const char *str)
+{
+ return parse_inject_common(str, true, "fault");
+}
+
+void
+apply_read(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_READ;
+}
+
+void
+apply_write(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_WRITE;
+}
+
+void
+apply_raw(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_RAW;
+}
+
+void
+apply_abbrev(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_ABBREV;
+}
+
+void
+apply_verbose(struct tcb *tcp, void *_priv_data)
+{
+ tcp->qual_flg |= QUAL_VERBOSE;
+}
diff --git a/basic_filters.c b/basic_filters.c
index 7b7f0a54..578df40c 100644
--- a/basic_filters.c
+++ b/basic_filters.c
@@ -202,18 +202,14 @@ qualify_syscall(const char *token, struct number_set *set)
* according to STR specification.
*/
void
-qualify_syscall_tokens(const char *const str, struct number_set *const set,
- const char *const name)
+qualify_syscall_tokens(const char *const str, struct number_set *const set)
{
- /* Clear all sets. */
- clear_number_set_array(set, SUPPORTED_PERSONALITIES);
-
/*
* Each leading ! character means inversion
* of the remaining specification.
*/
const char *s = str;
-handle_inversion:
+
while (*s == '!') {
invert_number_set_array(set, SUPPORTED_PERSONALITIES);
++s;
@@ -227,8 +223,8 @@ handle_inversion:
*/
return;
} else if (strcmp(s, "all") == 0) {
- s = "!none";
- goto handle_inversion;
+ invert_number_set_array(set, SUPPORTED_PERSONALITIES);
+ return;
}
/*
@@ -247,17 +243,43 @@ handle_inversion:
token = strtok_r(NULL, ",", &saveptr)) {
done = qualify_syscall(token, set);
if (!done) {
- error_msg_and_die("invalid %s '%s'", name, token);
+ error_msg_and_die("invalid system call '%s'", token);
}
}
free(copy);
if (!done) {
- error_msg_and_die("invalid %s '%s'", name, str);
+ error_msg_and_die("invalid system call '%s'", str);
}
}
+void *
+parse_syscall_filter(const char *str)
+{
+ struct number_set *set;
+
+ set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
+ qualify_syscall_tokens(str, set);
+ return set;
+}
+
+bool
+run_syscall_filter(struct tcb *tcp, void *_priv_data)
+{
+ struct number_set *set = _priv_data;
+
+ return is_number_in_set_array(tcp->scno, set, current_personality);
+}
+
+void
+free_syscall_filter(void *_priv_data)
+{
+ struct number_set *set = _priv_data;
+
+ free_number_set_array(set, SUPPORTED_PERSONALITIES);
+}
+
/*
* Add numbers to SET according to STR specification.
*/
@@ -265,15 +287,12 @@ void
qualify_tokens(const char *const str, struct number_set *const set,
string_to_uint_func func, const char *const name)
{
- /* Clear the set. */
- clear_number_set_array(set, 1);
-
/*
* Each leading ! character means inversion
* of the remaining specification.
*/
const char *s = str;
-handle_inversion:
+
while (*s == '!') {
invert_number_set_array(set, 1);
++s;
@@ -287,8 +306,8 @@ handle_inversion:
*/
return;
} else if (strcmp(s, "all") == 0) {
- s = "!none";
- goto handle_inversion;
+ invert_number_set_array(set, 1);
+ return;
}
/*
@@ -319,3 +338,63 @@ handle_inversion:
error_msg_and_die("invalid %s '%s'", name, str);
}
}
+
+void *
+parse_fd_filter(const char *str)
+{
+ struct number_set *set;
+
+ set = alloc_number_set_array(1);
+ qualify_tokens(str, set, string_to_uint, "descriptor");
+ return set;
+}
+
+bool
+run_fd_filter(struct tcb *tcp, void *_priv_data)
+{
+ int fd = tcp->u_arg[0];
+ struct number_set *set = _priv_data;
+
+ if (fd < 0)
+ return false;
+ return is_number_in_set(fd, set);
+}
+
+void
+free_fd_filter(void *_priv_data)
+{
+ struct number_set *set = _priv_data;
+
+ free_number_set_array(set, 1);
+ return;
+}
+
+void *
+parse_path_filter(const char *path, const char *const name)
+{
+ struct path_set *set = xcalloc(1, sizeof(struct path_set));
+
+ pathtrace_select_set(path, set);
+ return set;
+}
+
+bool
+run_path_filter(struct tcb *tcp, void *_priv_data)
+{
+ struct path_set *set = _priv_data;
+
+ return pathtrace_match_set(tcp, set);
+}
+
+void
+free_path_filter(void *_priv_data)
+{
+ struct path_set *set = _priv_data;
+ unsigned int i;
+
+ for (i = 0; i < set->num_selected; ++i)
+ free((char *) set->paths_selected[i]);
+ free(set->paths_selected);
+ free(set);
+ return;
+}
diff --git a/defs.h b/defs.h
index 87f831f1..4bd8d9e0 100644
--- a/defs.h
+++ b/defs.h
@@ -185,6 +185,7 @@ struct inject_opts {
uint16_t step;
uint16_t signo;
int rval;
+ bool init;
};
#define MAX_ERRNO_VALUE 4095
@@ -650,7 +651,8 @@ print_struct_statfs64(struct tcb *, kernel_ulong_t addr,
kernel_ulong_t size);
extern void print_ifindex(unsigned int);
extern void qualify(const char *);
-extern unsigned int qual_flags(const unsigned int);
+extern void filtering_parsing_finish(void);
+extern void filter_syscall(struct tcb *);
#define DECL_IOCTL(name) \
extern int \
diff --git a/filter.c b/filter.c
new file mode 100644
index 00000000..9c9b7e0d
--- /dev/null
+++ b/filter.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikola...@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include "filter.h"
+
+#define DECL_FILTER(name) \
+extern void * \
+parse_ ## name ## _filter(const char *); \
+extern bool \
+run_ ## name ## _filter(struct tcb *, void *); \
+extern void \
+free_ ## name ## _filter(void *) \
+/* End of DECL_FILTER definition. */
+
+DECL_FILTER(syscall);
+DECL_FILTER(fd);
+DECL_FILTER(path);
+#undef DECL_FILTER
+
+#define FILTER_TYPE(name) \
+{#name, parse_ ## name ## _filter, run_ ## name ## _filter, \
+ free_ ## name ## _filter}
+/* End of FILTER_TYPE definition. */
+
+static const struct filter_type {
+ const char *name;
+ void *(*parse_filter)(const char *);
+ bool (*run_filter)(struct tcb *, void *);
+ void (*free_priv_data)(void *);
+} filter_types[] = {
+ FILTER_TYPE(syscall),
+ FILTER_TYPE(fd),
+ FILTER_TYPE(path),
+};
+#undef FILTER_TYPE
+
+struct filter {
+ const struct filter_type *type;
+ void *_priv_data;
+};
+
+static const struct filter_type *
+lookup_filter_type(const char *str)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(filter_types); i++) {
+ if (!strcmp(filter_types[i].name, str))
+ return &filter_types[i];
+ }
+ return NULL;
+}
+
+struct filter *
+add_filter_to_array(struct filter **filters, unsigned int *nfilters,
+ const char *name)
+{
+ const struct filter_type *type = lookup_filter_type(name);
+ struct filter *filter;
+
+ if (!type)
+ error_msg_and_die("invalid filter '%s'", name);
+ *filters = xreallocarray(*filters, ++(*nfilters),
+ sizeof(struct filter));
+ filter = &((*filters)[*nfilters - 1]);
+ filter->type = type;
+ return filter;
+}
+
+void
+parse_filter(struct filter *filter, const char *str)
+{
+ filter->_priv_data = filter->type->parse_filter(str);
+}
+
+static bool
+run_filter(struct tcb *tcp, struct filter *filter)
+{
+ return filter->type->run_filter(tcp, filter->_priv_data);
+}
+
+void
+run_filters(struct tcb *tcp, struct filter *filters, unsigned int nfilters,
+ bool *variables_buf)
+{
+ unsigned int i;
+
+ for (i = 0; i < nfilters; ++i)
+ variables_buf[i] = run_filter(tcp, &filters[i]);
+}
+
+void
+free_filter(struct filter *filter)
+{
+ if (!filter)
+ return;
+ filter->type->free_priv_data(filter->_priv_data);
+}
+
+void
+set_filter_priv_data(struct filter *filter, void *_priv_data)
+{
+ if (filter)
+ filter->_priv_data = _priv_data;
+}
+
+void
+set_filters_qualify_mode(struct filter **filters, unsigned int *nfilters,
+ unsigned int filters_left)
+{
+ unsigned int i;
+
+ for (i = 0; i < *nfilters - filters_left; ++i)
+ free_filter(*filters + i);
+ for (i = 0; i < filters_left; ++i)
+ (*filters)[i] = (*filters)[*nfilters - filters_left + i];
+ *filters = xreallocarray(*filters, filters_left, sizeof(struct filter));
+ *nfilters = filters_left;
+}
diff --git a/filter.h b/filter.h
index fab18127..e340aac3 100644
--- a/filter.h
+++ b/filter.h
@@ -30,11 +30,41 @@
#define STRACE_FILTER_H
struct number_set;
+
+struct filter;
+
+struct filter_action;
+
+struct bool_expression;
+
typedef int (*string_to_uint_func)(const char *);
void qualify_tokens(const char *str, struct number_set *set,
string_to_uint_func func, const char *name);
-void qualify_syscall_tokens(const char *str, struct number_set *set,
- const char *name);
+void qualify_syscall_tokens(const char *str, struct number_set *set);
+void parse_inject_common_args(char *, struct inject_opts *,
+ const bool fault_tokens_only, bool qualify_mode);
+
+/* filter api */
+struct filter* add_filter_to_array(struct filter **, unsigned int *nfilters,
+ const char *name);
+void parse_filter(struct filter *, const char *str);
+void run_filters(struct tcb *, struct filter *, unsigned int, bool *);
+void free_filter(struct filter *);
+void set_filter_priv_data(struct filter *, void *);
+void set_filters_qualify_mode(struct filter **, unsigned int *nfilters,
+ unsigned int filters_left);
+
+/* filter action api */
+struct filter *create_filter(struct filter_action *, const char *name);
+struct filter_action *find_or_add_action(const char *);
+void set_filter_action_priv_data(struct filter_action *, void *);
+void set_qualify_mode(struct filter_action *, unsigned int);
+
+/* filter expression api */
+struct bool_expression *create_expression();
+bool run_expression(struct bool_expression *, bool *, unsigned int);
+void set_expression_qualify_mode(struct bool_expression *, unsigned int);
+void expression_add_filter_and(struct bool_expression *, unsigned int);
#endif /* !STRACE_FILTER_H */
diff --git a/filter_action.c b/filter_action.c
new file mode 100644
index 00000000..0f75f2e5
--- /dev/null
+++ b/filter_action.c
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikola...@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include "filter.h"
+
+#define DECL_FILTER_ACTION(name) \
+extern void \
+apply_ ## name(struct tcb *, void *) \
+/* End of DECL_FILTER_ACTION definition. */
+
+DECL_FILTER_ACTION(trace);
+DECL_FILTER_ACTION(inject);
+DECL_FILTER_ACTION(fault);
+DECL_FILTER_ACTION(read);
+DECL_FILTER_ACTION(write);
+DECL_FILTER_ACTION(raw);
+DECL_FILTER_ACTION(abbrev);
+DECL_FILTER_ACTION(verbose);
+#undef DECL_FILTER_ACTION
+
+extern bool is_traced(struct tcb *);
+extern bool not_injected(struct tcb *);
+
+#define DECL_FILTER_ACTION_PARSER(name)
\
+extern void * \
+parse_ ## name(const char *); \
+/* End of DECL_FILTER_ACTION_PARSER definition. */
+
+DECL_FILTER_ACTION_PARSER(null);
+DECL_FILTER_ACTION_PARSER(inject);
+DECL_FILTER_ACTION_PARSER(fault);
+#undef DECL_FILTER_ACTION_PARSER
+
+#define FILTER_ACTION_TYPE(NAME, PRIORITY, FLAG, PARSER, PREFILTER) \
+{#NAME, PRIORITY, FLAG, parse_ ## PARSER, PREFILTER, apply_ ## NAME}
+/* End of FILTER_ACTION_TYPE definition. */
+
+static const struct filter_action_type {
+ const char *name;
+ /* The highest priority is 0. */
+ unsigned int priority;
+ unsigned int qual_flg;
+ void * (*parse_args)(const char *);
+ bool (*prefilter)(struct tcb *);
+ void (*apply)(struct tcb *, void *);
+} action_types[] = {
+ FILTER_ACTION_TYPE(trace, 0, QUAL_TRACE, null, NULL),
+ FILTER_ACTION_TYPE(inject, 1, QUAL_INJECT, inject,
not_injected),
+ FILTER_ACTION_TYPE(fault, 1, QUAL_INJECT, fault,
not_injected),
+ FILTER_ACTION_TYPE(read, 2, QUAL_READ, null,
is_traced),
+ FILTER_ACTION_TYPE(write, 2, QUAL_WRITE, null,
is_traced),
+ FILTER_ACTION_TYPE(raw, 2, QUAL_RAW, null,
is_traced),
+ FILTER_ACTION_TYPE(abbrev, 2, QUAL_ABBREV, null,
is_traced),
+ FILTER_ACTION_TYPE(verbose, 2, QUAL_VERBOSE, null,
is_traced),
+};
+#undef FILTER_ACTION_TYPE
+
+struct filter_action {
+ /* Used to correct order of actions with the same priority. */
+ unsigned int id;
+ const struct filter_action_type *type;
+ struct bool_expression *expr;
+ unsigned int nfilters;
+ struct filter *filters;
+ void *_priv_data;
+};
+
+static struct filter_action *filter_actions;
+static unsigned int nfilter_actions;
+
+static bool *variables_buf;
+
+/*
+ * Compares action priorities. If actions have the same priority,
+ * uses LIFO order.
+ */
+static int
+compare_action_priority(const void *a, const void *b)
+{
+ const struct filter_action *action_a = a;
+ const struct filter_action *action_b = b;
+ unsigned int priority_a = action_a->type->priority;
+ unsigned int priority_b = action_b->type->priority;
+
+ if (priority_a != priority_b) {
+ return (priority_a < priority_b) ? -1 : 1;
+ } else {
+ return (action_a->id > action_b->id) ? -1 : 1;
+ }
+}
+
+static void
+inject_path_tracing(void)
+{
+ struct filter_action *action = find_or_add_action("trace");
+ struct filter *path_filter;
+
+ if (!action->nfilters)
+ qualify("trace=all");
+ path_filter = add_filter_to_array(&action->filters, &action->nfilters,
+ "path");
+ set_filter_priv_data(path_filter, &global_path_set);
+ expression_add_filter_and(action->expr, action->nfilters - 1);
+}
+
+void
+filtering_parsing_finish(void)
+{
+ unsigned int maxfilters = 0;
+ unsigned int i;
+
+ /* Inject path filter into trace action. */
+ if (tracing_paths)
+ inject_path_tracing();
+
+ /* Sort actions by priority */
+ if (nfilter_actions == 0)
+ return;
+ qsort(filter_actions, nfilter_actions, sizeof(struct filter_action),
+ &compare_action_priority);
+
+ /* Allocate variables_buf sufficient for any action */
+ for (i = 0; i < nfilter_actions; ++i) {
+ if (filter_actions[i].nfilters > maxfilters)
+ maxfilters = filter_actions[i].nfilters;
+ }
+ variables_buf = xcalloc(maxfilters, sizeof(bool));
+}
+
+static const struct filter_action_type *
+lookup_filter_action_type(const char *str)
+{
+ unsigned int i;
+
+ for (i = 0; i < ARRAY_SIZE(action_types); ++i) {
+ if (!strcmp(action_types[i].name, str))
+ return &action_types[i];
+ }
+ return NULL;
+}
+
+static struct filter_action *
+add_action(const struct filter_action_type *type)
+{
+ struct filter_action *action;
+
+ filter_actions = xreallocarray(filter_actions, ++nfilter_actions,
+ sizeof(struct filter_action));
+ action = &filter_actions[nfilter_actions - 1];
+ memset(action, 0, sizeof(*action));
+ action->id = nfilter_actions - 1;
+ action->type = type;
+ action->expr = create_expression();
+ return action;
+}
+
+struct filter_action *
+find_or_add_action(const char *name)
+{
+ const struct filter_action_type *type = lookup_filter_action_type(name);
+ unsigned int i;
+
+ if (!type)
+ error_msg_and_die("invalid filter action '%s'", name);
+ /* If action takes arguments, add new action */
+ if (type->parse_args != &parse_null)
+ return add_action(type);
+
+ for (i = 0; i < nfilter_actions; ++i) {
+ if (filter_actions[i].type == type)
+ return &filter_actions[i];
+ }
+ return add_action(type);
+}
+
+static void
+run_filter_action(struct tcb *tcp, struct filter_action *action)
+{
+ if (action->type->prefilter && !action->type->prefilter(tcp))
+ return;
+ run_filters(tcp, action->filters, action->nfilters, variables_buf);
+ if (run_expression(action->expr, variables_buf, action->nfilters))
+ action->type->apply(tcp, action->_priv_data);
+}
+
+struct filter *
+create_filter(struct filter_action *action, const char *name)
+{
+ return add_filter_to_array(&action->filters, &action->nfilters, name);
+}
+
+void
+set_qualify_mode(struct filter_action *action, unsigned int filters_left)
+{
+ set_filters_qualify_mode(&action->filters, &action->nfilters,
+ filters_left);
+ set_expression_qualify_mode(action->expr, filters_left);
+
+}
+
+void
+filter_syscall(struct tcb *tcp)
+{
+ unsigned int i;
+
+ for (i = 0; i < nfilter_actions; ++i)
+ run_filter_action(tcp, &filter_actions[i]);
+}
+
+void
+set_filter_action_priv_data(struct filter_action *action, void *_priv_data)
+{
+ if (action)
+ action->_priv_data = _priv_data;
+}
diff --git a/filter_expression.c b/filter_expression.c
new file mode 100644
index 00000000..73aaae3a
--- /dev/null
+++ b/filter_expression.c
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikola...@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "defs.h"
+#include <stdarg.h>
+#include "filter.h"
+
+struct expression_token {
+ enum token_type {
+ TOK_VARIABLE,
+ TOK_OPERATOR
+ } type;
+ union token_data {
+ unsigned int variable_id;
+ enum operator_type {
+ OP_NOT,
+ OP_AND,
+ OP_OR
+ } operator_id;
+ } data;
+};
+
+struct bool_expression {
+ unsigned int ntokens;
+ struct expression_token *tokens;
+};
+
+struct bool_expression *
+create_expression(void)
+{
+ return xcalloc(1, sizeof(struct bool_expression));
+}
+
+static void
+reallocate_expression(struct bool_expression *const expr,
+ const unsigned int new_ntokens)
+{
+ if (!expr)
+ error_msg_and_die("invalid expression");
+ expr->tokens = xreallocarray(expr->tokens, new_ntokens,
+ sizeof(*expr->tokens));
+ if (new_ntokens > expr->ntokens)
+ memset(expr->tokens + expr->ntokens, 0,
+ sizeof(*expr->tokens) * (new_ntokens - expr->ntokens));
+ expr->ntokens = new_ntokens;
+}
+
+static void
+add_variable_token(struct bool_expression *expr, unsigned int id)
+{
+ struct expression_token token;
+ token.type = TOK_VARIABLE;
+ token.data.variable_id = id;
+ reallocate_expression(expr, expr->ntokens + 1);
+ expr->tokens[expr->ntokens - 1] = token;
+}
+
+static void
+add_operator_token(struct bool_expression *expr, int op) {
+ struct expression_token token;
+ token.type = TOK_OPERATOR;
+ token.data.operator_id = op;
+ reallocate_expression(expr, expr->ntokens + 1);
+ expr->tokens[expr->ntokens - 1] = token;
+}
+
+void
+expression_add_filter_and(struct bool_expression *expr, unsigned int filter_id)
+{
+ add_variable_token(expr, filter_id);
+ add_operator_token(expr, OP_AND);
+}
+
+void
+set_expression_qualify_mode(struct bool_expression *expr,
+ unsigned int filters_left)
+{
+ unsigned int i;
+
+ if (!expr)
+ error_msg_and_die("invalid expression");
+ reallocate_expression(expr, 2 * filters_left - 1);
+ for (i = 0; i < filters_left; ++i) {
+ expr->tokens[i].type = TOK_VARIABLE;
+ expr->tokens[i].data.variable_id = i;
+ }
+ for (; i < 2 * filters_left - 1; ++i) {
+ expr->tokens[i].type = TOK_OPERATOR;
+ expr->tokens[i].data.operator_id = OP_AND;
+ }
+}
+
+ATTRIBUTE_FORMAT((printf, 3, 4))
+static int
+printf_append(char **ptr, char *end, const char *fmt, ...)
+ {
+ int ret;
+ va_list args;
+
+ va_start(args, fmt);
+ ret = vsnprintf(*ptr, end - *ptr, fmt, args);
+ va_end(args);
+
+ if (ret < 0)
+ return ret;
+
+ *ptr += MIN(ret, end - *ptr);
+ return ret;
+}
+
+/* Print full diagnostics for corrupted expression */
+ATTRIBUTE_NORETURN
+static void
+handle_corrupted_expression(struct bool_expression *expr, bool *stack,
+ unsigned int stack_size, unsigned int current_pos,
+ bool *variables, unsigned int variables_num)
+{
+ char *buf, *pos, *end;
+ unsigned int buf_size;
+ unsigned int i;
+
+ /* Calculate buffer size. */
+ buf_size = sizeof("corrupted filter expression:");
+ buf_size += sizeof("expression (ntokens = ):")
+ + 3 * sizeof(unsigned int)
+ + (sizeof("op_") + 3 * sizeof(int)) * expr->ntokens;
+ buf_size += sizeof("variables (nvariables = ):") + 3 * sizeof(int)
+ + sizeof("false") * variables_num;
+ buf_size += sizeof("current position: ") + 3 * sizeof(int);
+ buf_size += sizeof("stack (stack_size = ):") + 3 * sizeof(int)
+ + sizeof("false") * stack_size;
+
+ buf = xcalloc(buf_size, 1);
+ pos = buf;
+ end = buf + buf_size;
+
+ printf_append(&pos, end, "corrupted filter expression:\n");
+
+ /* Print expression. */
+ printf_append(&pos, end, "expression (ntokens = %u):", expr->ntokens);
+ for (i = 0; i < expr->ntokens; ++i) {
+ switch (expr->tokens[i].type) {
+ case TOK_VARIABLE:
+ printf_append(&pos, end, " v_%u",
+ expr->tokens[i].data.variable_id);
+ break;
+ case TOK_OPERATOR:
+ switch (expr->tokens[i].data.operator_id) {
+ case OP_NOT:
+ printf_append(&pos, end, " not");
+ break;
+ case OP_AND:
+ printf_append(&pos, end, " and");
+ break;
+ case OP_OR:
+ printf_append(&pos, end, " or");
+ break;
+ default:
+ printf_append(&pos, end, " op_%d",
+ expr->tokens[i].data.operator_id);
+ }
+ break;
+ default:
+ printf_append(&pos, end, " ?_%d", expr->tokens[i].type);
+ }
+ }
+ printf_append(&pos, end, "\n");
+
+ /* Print variables. */
+ printf_append(&pos, end, "variables (nvariables = %u):", variables_num);
+ for (i = 0; i < variables_num; ++i)
+ printf_append(&pos, end, !variables[i] ? " false" : " true");
+ printf_append(&pos, end, "\n");
+
+ printf_append(&pos, end, "current position: %u\n", current_pos);
+
+ /* Print current stack state. */
+ printf_append(&pos, end, "stack (stack_size = %u):", stack_size);
+ for (i = 0; i < stack_size; ++i)
+ printf_append(&pos, end, !stack[i] ? " false" : " true");
+
+ error_msg_and_die("%s", buf);
+}
+
+#define MAX_STACK_SIZE 32
+
+bool
+run_expression(struct bool_expression *expr, bool *variables,
+ unsigned int variables_num)
+{
+ bool stack[MAX_STACK_SIZE];
+ unsigned int stack_size = 0;
+ unsigned int i;
+
+ for (i = 0; i < expr->ntokens; ++i) {
+ struct expression_token *tok = &expr->tokens[i];
+
+ switch (tok->type) {
+ case TOK_VARIABLE:
+ if (stack_size == MAX_STACK_SIZE)
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+
+ if (tok->data.variable_id >= variables_num)
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+ stack[stack_size++] = variables[tok->data.variable_id];
+ break;
+ case TOK_OPERATOR:
+ switch (tok->data.operator_id) {
+ case OP_NOT:
+ if (stack_size == 0)
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+ stack[stack_size - 1] = !stack[stack_size - 1];
+ break;
+ case OP_AND:
+ if (stack_size < 2)
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+ stack[stack_size - 2] = stack[stack_size - 2]
+ && stack[stack_size - 1];
+ --stack_size;
+ break;
+ case OP_OR:
+ if (stack_size < 2)
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+ stack[stack_size - 2] = stack[stack_size - 2]
+ || stack[stack_size - 1];
+ --stack_size;
+ break;
+ default:
+ handle_corrupted_expression(expr, stack,
+ stack_size, i,
+ variables,
+ variables_num);
+ }
+ break;
+ }
+ }
+
+ if (stack_size != 1)
+ handle_corrupted_expression(expr, stack, stack_size, i,
+ variables, variables_num);
+ return stack[0];
+}
diff --git a/filter_qualify.c b/filter_qualify.c
index b59b19b9..f195743a 100644
--- a/filter_qualify.c
+++ b/filter_qualify.c
@@ -31,16 +31,8 @@
#include "number_set.h"
#include "filter.h"
-struct number_set *read_set;
-struct number_set *write_set;
struct number_set *signal_set;
-static struct number_set *abbrev_set;
-static struct number_set *inject_set;
-static struct number_set *raw_set;
-static struct number_set *trace_set;
-static struct number_set *verbose_set;
-
static int
sigstr_to_uint(const char *s)
{
@@ -149,46 +141,57 @@ parse_inject_token(const char *const token, struct
inject_opts *const fopts,
return true;
}
-static char *
-parse_inject_expression(const char *const s, char **buf,
- struct inject_opts *const fopts,
- const bool fault_tokens_only)
+void
+parse_inject_common_args(char *str, struct inject_opts *const opts,
+ const bool fault_tokens_only, bool qualify_mode)
{
char *saveptr = NULL;
- char *name = NULL;
char *token;
-
- *buf = xstrdup(s);
- for (token = strtok_r(*buf, ":", &saveptr); token;
- token = strtok_r(NULL, ":", &saveptr)) {
- if (!name)
- name = token;
- else if (!parse_inject_token(token, fopts, fault_tokens_only))
- goto parse_error;
+ const char *delim = qualify_mode ? ":" : ";";
+
+ opts->first = 1;
+ opts->step = 1;
+ opts->rval = INJECT_OPTS_RVAL_DEFAULT;
+ opts->signo = 0;
+ opts->init = false;
+
+ for (token = strtok_r(str, delim, &saveptr); token;
+ token = strtok_r(NULL, delim, &saveptr)) {
+ if (!parse_inject_token(token, opts, fault_tokens_only))
+ return;
}
- if (name)
- return name;
-
-parse_error:
- free(*buf);
- return *buf = NULL;
+ /* If neither of retval, error, or signal is specified, then ... */
+ if (opts->rval == INJECT_OPTS_RVAL_DEFAULT && !opts->signo) {
+ if (fault_tokens_only) {
+ /* in fault syntax the default error code is ENOSYS. */
+ opts->rval = -ENOSYS;
+ } else {
+ /* in inject syntax this is not allowed. */
+ return;
+ }
+ }
+ opts->init = true;
}
static void
qualify_read(const char *const str)
{
- if (!read_set)
- read_set = alloc_number_set_array(1);
- qualify_tokens(str, read_set, string_to_uint, "descriptor");
+ struct filter_action *action = find_or_add_action("read");
+ struct filter *filter = create_filter(action, "fd");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
qualify_write(const char *const str)
{
- if (!write_set)
- write_set = alloc_number_set_array(1);
- qualify_tokens(str, write_set, string_to_uint, "descriptor");
+ struct filter_action *action = find_or_add_action("write");
+ struct filter *filter = create_filter(action, "fd");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
@@ -196,39 +199,49 @@ qualify_signals(const char *const str)
{
if (!signal_set)
signal_set = alloc_number_set_array(1);
+ else
+ clear_number_set_array(signal_set, 1);
qualify_tokens(str, signal_set, sigstr_to_uint, "signal");
}
static void
qualify_trace(const char *const str)
{
- if (!trace_set)
- trace_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
- qualify_syscall_tokens(str, trace_set, "system call");
+ struct filter_action *action = find_or_add_action("trace");
+ struct filter *filter = create_filter(action, "syscall");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
qualify_abbrev(const char *const str)
{
- if (!abbrev_set)
- abbrev_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
- qualify_syscall_tokens(str, abbrev_set, "system call");
+ struct filter_action *action = find_or_add_action("abbrev");
+ struct filter *filter = create_filter(action, "syscall");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
qualify_verbose(const char *const str)
{
- if (!verbose_set)
- verbose_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
- qualify_syscall_tokens(str, verbose_set, "system call");
+ struct filter_action *action = find_or_add_action("verbose");
+ struct filter *filter = create_filter(action, "syscall");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
qualify_raw(const char *const str)
{
- if (!raw_set)
- raw_set = alloc_number_set_array(SUPPORTED_PERSONALITIES);
- qualify_syscall_tokens(str, raw_set, "system call");
+ struct filter_action *action = find_or_add_action("raw");
+ struct filter *filter = create_filter(action, "syscall");
+
+ parse_filter(filter, str);
+ set_qualify_mode(action, 1);
}
static void
@@ -236,75 +249,39 @@ qualify_inject_common(const char *const str,
const bool fault_tokens_only,
const char *const description)
{
- struct inject_opts opts = {
- .first = 1,
- .step = 1,
- .rval = INJECT_OPTS_RVAL_DEFAULT,
- .signo = 0
- };
- char *buf = NULL;
- char *name = parse_inject_expression(str, &buf, &opts,
fault_tokens_only);
- if (!name) {
- error_msg_and_die("invalid %s '%s'", description, str);
- }
-
- /* If neither of retval, error, or signal is specified, then ... */
- if (opts.rval == INJECT_OPTS_RVAL_DEFAULT && !opts.signo) {
- if (fault_tokens_only) {
- /* in fault= syntax the default error code is ENOSYS. */
- opts.rval = -ENOSYS;
- } else {
- /* in inject= syntax this is not allowed. */
- error_msg_and_die("invalid %s '%s'", description, str);
- }
- }
-
- struct number_set *tmp_set =
- alloc_number_set_array(SUPPORTED_PERSONALITIES);
- qualify_syscall_tokens(name, tmp_set, description);
-
+ struct inject_opts *opts = xmalloc(sizeof(struct inject_opts));
+ char *buf = xstrdup(str);
+ struct filter_action *action;
+ struct filter *filter;
+ char *args = strchr(buf, ':');
+
+ if (args)
+ *(args++) = '\0';
+
+ action = find_or_add_action(fault_tokens_only ? "fault" : "inject");
+ filter = create_filter(action, "syscall");
+ parse_filter(filter, buf);
+ set_qualify_mode(action, 1);
+ parse_inject_common_args(args, opts, fault_tokens_only, true);
+
+ if (!opts->init)
+ error_msg_and_die("invalid %s argument '%s'", description,
+ args ? args : "");
free(buf);
- /*
- * Initialize inject_vec accourding to tmp_set.
- * Merge tmp_set into inject_set.
- */
- unsigned int p;
- for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
- if (number_set_array_is_empty(tmp_set, p))
- continue;
-
- if (!inject_set) {
- inject_set =
- alloc_number_set_array(SUPPORTED_PERSONALITIES);
- }
- if (!inject_vec[p]) {
- inject_vec[p] = xcalloc(nsyscall_vec[p],
- sizeof(*inject_vec[p]));
- }
-
- unsigned int i;
- for (i = 0; i < nsyscall_vec[p]; ++i) {
- if (is_number_in_set_array(i, tmp_set, p)) {
- add_number_to_set_array(i, inject_set, p);
- inject_vec[p][i] = opts;
- }
- }
- }
-
- free_number_set_array(tmp_set, SUPPORTED_PERSONALITIES);
+ set_filter_action_priv_data(action, opts);
}
static void
qualify_fault(const char *const str)
{
- qualify_inject_common(str, true, "fault argument");
+ qualify_inject_common(str, true, "fault");
}
static void
qualify_inject(const char *const str)
{
- qualify_inject_common(str, false, "inject argument");
+ qualify_inject_common(str, false, "inject");
}
static const struct qual_options {
@@ -352,18 +329,3 @@ qualify(const char *str)
opt->qualify(str);
}
-
-unsigned int
-qual_flags(const unsigned int scno)
-{
- return (is_number_in_set_array(scno, trace_set, current_personality)
- ? QUAL_TRACE : 0)
- | (is_number_in_set_array(scno, abbrev_set, current_personality)
- ? QUAL_ABBREV : 0)
- | (is_number_in_set_array(scno, verbose_set,
current_personality)
- ? QUAL_VERBOSE : 0)
- | (is_number_in_set_array(scno, raw_set, current_personality)
- ? QUAL_RAW : 0)
- | (is_number_in_set_array(scno, inject_set, current_personality)
- ? QUAL_INJECT : 0);
-}
diff --git a/number_set.h b/number_set.h
index 967a1c88..5c17e803 100644
--- a/number_set.h
+++ b/number_set.h
@@ -57,8 +57,6 @@ alloc_number_set_array(unsigned int nmemb);
extern void
free_number_set_array(struct number_set *, unsigned int nmemb);
-extern struct number_set *read_set;
-extern struct number_set *write_set;
extern struct number_set *signal_set;
#endif /* !STRACE_NUMBER_SET_H */
diff --git a/pathtrace.c b/pathtrace.c
index 52582380..23a352ef 100644
--- a/pathtrace.c
+++ b/pathtrace.c
@@ -91,7 +91,7 @@ storepath(const char *path, struct path_set *set)
set->paths_selected = xreallocarray(set->paths_selected,
set->num_selected,
sizeof(set->paths_selected[0]));
- set->paths_selected[i] = path;
+ set->paths_selected[i] = xstrdup(path);
}
/*
diff --git a/strace.c b/strace.c
index 6ed86a6f..3fa15a5c 100644
--- a/strace.c
+++ b/strace.c
@@ -771,7 +771,8 @@ droptcb(struct tcb *tcp)
int p;
for (p = 0; p < SUPPORTED_PERSONALITIES; ++p)
- free(tcp->inject_vec[p]);
+ if (tcp->inject_vec[p])
+ free(tcp->inject_vec[p]);
free_tcb_priv_data(tcp);
@@ -1713,6 +1714,7 @@ init(int argc, char *argv[])
break;
}
}
+ filtering_parsing_finish();
argv += optind;
argc -= optind;
@@ -2415,6 +2417,8 @@ trace_syscall(struct tcb *tcp, unsigned int *sig)
case 0:
return 0;
case 1:
+ if (!tcp->qual_flg)
+ filter_syscall(tcp);
res = syscall_entering_trace(tcp, sig);
}
syscall_entering_finish(tcp, res);
diff --git a/syscall.c b/syscall.c
index 6b1d2dcd..492858ca 100644
--- a/syscall.c
+++ b/syscall.c
@@ -346,7 +346,6 @@ decode_socket_subcall(struct tcb *tcp)
return;
tcp->scno = scno;
- tcp->qual_flg = qual_flags(scno);
tcp->s_ent = &sysent[scno];
unsigned int i;
@@ -386,7 +385,6 @@ decode_ipc_subcall(struct tcb *tcp)
}
tcp->scno = SYS_ipc_subcall + call;
- tcp->qual_flg = qual_flags(tcp->scno);
tcp->s_ent = &sysent[tcp->scno];
const unsigned int n = tcp->s_ent->nargs;
@@ -403,7 +401,6 @@ decode_mips_subcall(struct tcb *tcp)
if (!scno_is_valid(tcp->u_arg[0]))
return;
tcp->scno = tcp->u_arg[0];
- tcp->qual_flg = qual_flags(tcp->scno);
tcp->s_ent = &sysent[tcp->scno];
memmove(&tcp->u_arg[0], &tcp->u_arg[1],
sizeof(tcp->u_arg) - sizeof(tcp->u_arg[0]));
@@ -432,7 +429,7 @@ dumpio(struct tcb *tcp)
if (fd < 0)
return;
- if (is_number_in_set(fd, read_set)) {
+ if (dump_read(tcp)) {
switch (tcp->s_ent->sen) {
case SEN_read:
case SEN_pread:
@@ -455,7 +452,7 @@ dumpio(struct tcb *tcp)
return;
}
}
- if (is_number_in_set(fd, write_set)) {
+ if (dump_write(tcp)) {
switch (tcp->s_ent->sen) {
case SEN_write:
case SEN_pwrite:
@@ -541,8 +538,6 @@ static void get_error(struct tcb *, const bool);
static int arch_set_error(struct tcb *);
static int arch_set_success(struct tcb *);
-struct inject_opts *inject_vec[SUPPORTED_PERSONALITIES];
-
static struct inject_opts *
tcb_inject_opts(struct tcb *tcp)
{
@@ -554,14 +549,6 @@ tcb_inject_opts(struct tcb *tcp)
static long
tamper_with_syscall_entering(struct tcb *tcp, unsigned int *signo)
{
- if (!tcp->inject_vec[current_personality]) {
- tcp->inject_vec[current_personality] =
- xcalloc(nsyscalls, sizeof(**inject_vec));
- memcpy(tcp->inject_vec[current_personality],
- inject_vec[current_personality],
- nsyscalls * sizeof(**inject_vec));
- }
-
struct inject_opts *opts = tcb_inject_opts(tcp);
if (!opts || opts->first == 0)
@@ -1199,7 +1186,8 @@ get_scno(struct tcb *tcp)
if (scno_is_valid(tcp->scno)) {
tcp->s_ent = &sysent[tcp->scno];
- tcp->qual_flg = qual_flags(tcp->scno);
+ /* Clear qual_flg to distinguish valid syscall from printargs */
+ tcp->qual_flg = 0;
} else {
struct sysent_buf *s = xcalloc(1, sizeof(*s));
--
2.11.0
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, Slashdot.org! http://sdm.link/slashdot
_______________________________________________
Strace-devel mailing list
Strace-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/strace-devel
