On Thu, Jun 29, 2017 at 02:46:11PM +0700, Nikolay Marchuk wrote:
> This change introduces new filtering architecture primitives: filter,
> filter_action and bool_expression. It also changes processing of -e
> strace option. Now, filtering is done after decoding of syscall and
> tcp->qual_flg stores filtering results.
>
> * basic_actions.c: New file.
> * basic_filters.c: Rename functions, add new filters' functions.
> * defs.h (struct tcb): Change inject options variable.
> (QUAL_READ, QUAL_WRITE): Change description.
> (read_set, write_set): Remove global set variables.
> (is_number_in_set): Change declaration.
> (qualify, qual_flags): Remove old declarations ...
> (filter_syscall, parse_qualify_filter,
> sort_filter_actions): ... and add new declarations.
> * filter.c: New file.
> * filter.h: Change declarations.
> * filter_action.c: New file.
> * filter_expression.c: Likewise.
> * filter_qualify.c: Generate new filters.
> * Makefile.am (strace_SOURCES): Add new files.
> * strace.c (droptcb): Remove inject_vec freeing.
> (init): Change qualify to parse_qualify_filter.
> Add sorting of filter actions.
> (trace_syscall): Add filtering after syscall decoding.
> * syscall.c (decode_socket_subcall): Remove qual_flags from decoder.
> (decode_ipc_subcall): Likewise.
> (decode_mips_subcall): Likewise.
> (get_scno): Likewise.
> (inject_vec, tcb_inject_opts, tamper_with_syscall_entering,
> tamper_with_syscall_exiting): Remove inject_vec support code.
> (dumpio): Check tcp->qual_flg instead of global set.
> ---
> Makefile.am | 4 ++
> basic_actions.c | 98 +++++++++++++++++++++++++
> basic_filters.c | 107 ++++++++++++++++++++-------
> defs.h | 15 ++--
> filter.c | 147 +++++++++++++++++++++++++++++++++++++
> filter.h | 36 ++++++++--
> filter_action.c | 203
> ++++++++++++++++++++++++++++++++++++++++++++++++++++
> filter_expression.c | 131 +++++++++++++++++++++++++++++++++
> filter_qualify.c | 135 +++++++++++++++++-----------------
> strace.c | 20 +++---
> syscall.c | 31 ++------
> 11 files changed, 783 insertions(+), 144 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 4f5ebfb..7299141 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 \
> bjm.c \
> block.c \
> @@ -125,7 +126,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 \
> fs_x_ioctl.c \
> flock.c \
> diff --git a/basic_actions.c b/basic_actions.c
> new file mode 100644
> index 0000000..de87cde
> --- /dev/null
> +++ b/basic_actions.c
> @@ -0,0 +1,98 @@
> +/*
> + * 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"
> +
> +bool
> +is_traced(struct tcb *tcp)
> +{
> + return (tcp->qual_flg & QUAL_TRACE);
> +}
> +
> +void *
> +parse_null(const char *str)
> +{
> + return NULL;
> +}
> +
> +void
> +free_null(void *_priv_data)
> +{
> + return;
> +}
> +
> +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 **inject_vec = (struct inject_opts **)_priv_data;
This cast is useless.
> + tcp->qual_flg |= QUAL_INJECT;
> + tcp->inject_opts = (scno_in_range(tcp->scno) &&
> inject_vec[current_personality])
> + ? &inject_vec[current_personality][tcp->scno] : NULL;
> +}
> +void*
> +parse_inject(const char *str)
> +{
> + return NULL;
> +}
> +void free_inject(void *_priv_data)
> +{
> + struct inject_opts **vec = (struct inject_opts **)_priv_data;
This cast is useless.
> + unsigned int p;
> + for (p = 0; p < SUPPORTED_PERSONALITIES; ++p)
> + if (vec[p])
> + free(vec[p]);
> + free(vec);
> +}
> +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 316b733..d0816a4 100644
> --- a/basic_filters.c
> +++ b/basic_filters.c
> @@ -25,10 +25,8 @@
> * (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 <regex.h>
> -#include "filter.h"
>
> typedef unsigned int number_slot_t;
> #define BITS_PER_SLOT (sizeof(number_slot_t) * 8)
> @@ -39,6 +37,12 @@ struct number_set {
> bool not;
> };
>
> +bool
> +is_empty(struct number_set *set)
> +{
> + return !(set->nslots || set->not);
> +}
> +
> static void
> number_setbit(const unsigned int i, number_slot_t *const vec)
> {
> @@ -48,9 +52,11 @@ number_setbit(const unsigned int i, number_slot_t *const
> vec)
> static bool
> number_isset(const unsigned int i, const number_slot_t *const vec)
> {
> - return vec[i / BITS_PER_SLOT] & ((number_slot_t) 1 << (i %
> BITS_PER_SLOT));
> + return (vec[i / BITS_PER_SLOT]
> + & ((number_slot_t) 1 << (i % BITS_PER_SLOT))) ? true : false;
> }
>
> +
> static void
> reallocate_number_set(struct number_set *const set, const unsigned int
> new_nslots)
> {
> @@ -62,7 +68,7 @@ reallocate_number_set(struct number_set *const set, const
> unsigned int new_nslot
> set->nslots = new_nslots;
> }
>
> -void
> +static void
> add_number_to_set(const unsigned int number, struct number_set *const set)
> {
> reallocate_number_set(set, number / BITS_PER_SLOT + 1);
> @@ -77,7 +83,7 @@ is_number_in_set(const unsigned int number, const struct
> number_set *const set)
> }
>
> static bool
> -qualify_syscall_number(const char *s, struct number_set *set)
> +parse_syscall_number(const char *s, struct number_set *set)
> {
> int n = string_to_uint(s);
> if (n < 0)
> @@ -108,7 +114,7 @@ regerror_msg_and_die(int errcode, const regex_t *preg,
> }
>
> static bool
> -qualify_syscall_regex(const char *s, struct number_set *set)
> +parse_syscall_regex(const char *s, struct number_set *set)
> {
> regex_t preg;
> int rc;
> @@ -180,7 +186,7 @@ lookup_class(const char *s)
> }
>
> static bool
> -qualify_syscall_class(const char *s, struct number_set *set)
> +parse_syscall_class(const char *s, struct number_set *set)
> {
> const unsigned int n = lookup_class(s);
> if (!n)
> @@ -203,7 +209,7 @@ qualify_syscall_class(const char *s, struct number_set
> *set)
> }
>
> static bool
> -qualify_syscall_name(const char *s, struct number_set *set)
> +parse_syscall_name(const char *s, struct number_set *set)
> {
> unsigned int p;
> bool found = false;
> @@ -224,8 +230,9 @@ qualify_syscall_name(const char *s, struct number_set
> *set)
> return found;
> }
>
> +
> static bool
> -qualify_syscall(const char *token, struct number_set *set)
> +parse_syscall(const char *token, struct number_set *set)
> {
> bool ignore_fail = false;
>
> @@ -234,21 +241,17 @@ qualify_syscall(const char *token, struct number_set
> *set)
> ignore_fail = true;
> }
> if (*token >= '0' && *token <= '9')
> - return qualify_syscall_number(token, set) || ignore_fail;
> + return parse_syscall_number(token, set) || ignore_fail;
> if (*token == '/')
> - return qualify_syscall_regex(token + 1, set) || ignore_fail;
> - return qualify_syscall_class(token, set)
> - || qualify_syscall_name(token, set)
> + return parse_syscall_regex(token + 1, set) || ignore_fail;
> + return parse_syscall_class(token, set)
> + || parse_syscall_name(token, set)
> || ignore_fail;
> }
>
> -/*
> - * Add syscall numbers to SETs for each supported personality
> - * according to STR specification.
> - */
> -void
> -qualify_syscall_tokens(const char *const str, struct number_set *const set,
> - const char *const name)
> +static void
> +parse_syscall_set(const char *const str, struct number_set *const set,
> + const char *const name)
> {
> /* Clear all sets. */
> unsigned int p;
> @@ -298,7 +301,7 @@ handle_inversion:
>
> for (token = strtok_r(copy, ",", &saveptr); token;
> token = strtok_r(NULL, ",", &saveptr)) {
> - done = qualify_syscall(token, set);
> + done = parse_syscall(token, set);
> if (!done) {
> error_msg_and_die("invalid %s '%s'", name, token);
> }
> @@ -311,11 +314,37 @@ handle_inversion:
> }
> }
>
> -/*
> - * Add numbers to SET according to STR specification.
> - */
> +void*
> +parse_syscall_filter(const char *str, const char *const name)
> +{
> + struct number_set *set = xcalloc(SUPPORTED_PERSONALITIES,
> + sizeof(struct number_set));
> + parse_syscall_set(str, set, name);
> + return set;
> +}
> +
> +bool
> +run_syscall_filter(struct tcb *tcp, void *_priv_data)
> +{
> + struct number_set *set = (struct number_set *)_priv_data;
This cast is useless.
> + return is_number_in_set(tcp->scno, &set[current_personality]);
> +}
> +
> void
> -qualify_tokens(const char *const str, struct number_set *const set,
> +free_syscall_filter(void *_priv_data)
> +{
> + struct number_set *set = (struct number_set *)_priv_data;
This cast is useless.
> + unsigned int p;
> + for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
> + free(set[p].vec);
> + }
> + free(set);
> +}
> +
> +typedef int (*string_to_uint_func)(const char *);
> +
> +void
> +parse_set(const char *const str, struct number_set *const set,
> string_to_uint_func func, const char *const name)
> {
> /* Clear the set. */
> @@ -373,3 +402,31 @@ handle_inversion:
> error_msg_and_die("invalid %s '%s'", name, str);
> }
> }
> +
> +void*
> +parse_fd_filter(const char *str, const char *const name)
> +{
> + struct number_set *set = xmalloc(sizeof(struct number_set));
> + memset(set, 0, sizeof(struct number_set));
I think you should use xcalloc here.
> + parse_set(str, set, string_to_uint, name);
> + return set;
> +}
> +
> +bool
> +run_fd_filter(struct tcb *tcp, void *_priv_data)
> +{
> + int fd = tcp->u_arg[0];
> + if (fd < 0)
> + return false;
> + struct number_set *set = (struct number_set *)_priv_data;
This cast is useless.
> + return is_number_in_set(fd, set);
> +}
> +
> +void
> +free_fd_filter(void *_priv_data)
> +{
> + struct number_set *set = (struct number_set *)_priv_data;
This cast is useless.
> + free(set->vec);
> + free(set);
> + return;
> +}
> diff --git a/defs.h b/defs.h
> index 29a681b..9242b16 100644
> --- a/defs.h
> +++ b/defs.h
> @@ -228,7 +228,7 @@ struct tcb {
> void (*_free_priv_data)(void *); /* Callback for freeing priv_data */
> const struct_sysent *s_ent; /* sysent[scno] or dummy struct for bad
> scno */
> const struct_sysent *s_prev_ent; /* for "resuming interrupted SYSCALL"
> msg */
> - struct inject_opts *inject_vec[SUPPORTED_PERSONALITIES];
> + struct inject_opts *inject_opts;
> struct timeval stime; /* System time usage as of last process wait */
> struct timeval dtime; /* Delta for system time usage */
> struct timeval etime; /* Syscall entry time */
> @@ -272,8 +272,8 @@ struct tcb {
> #define QUAL_RAW 0x008 /* print all args in hex for this syscall */
> #define QUAL_INJECT 0x010 /* tamper with this system call on purpose */
> #define QUAL_SIGNAL 0x100 /* report events with this signal */
> -#define QUAL_READ 0x200 /* dump data read from this file descriptor */
> -#define QUAL_WRITE 0x400 /* dump data written to this file descriptor */
> +#define QUAL_READ 0x200 /* dump data read in this syscall */
> +#define QUAL_WRITE 0x400 /* dump data written in this syscall */
>
> #define DEFAULT_QUAL_FLAGS (QUAL_TRACE | QUAL_ABBREV | QUAL_VERBOSE)
>
> @@ -665,13 +665,12 @@ print_struct_statfs64(struct tcb *, kernel_ulong_t
> addr, kernel_ulong_t size);
> extern void print_ifindex(unsigned int);
>
> struct number_set;
> -extern struct number_set read_set;
> -extern struct number_set write_set;
> extern struct number_set signal_set;
>
> -extern bool is_number_in_set(unsigned int number, const struct number_set *);
> -extern void qualify(const char *);
> -extern unsigned int qual_flags(const unsigned int);
> +extern bool is_number_in_set(const unsigned int, const struct number_set *);
> +extern void sort_filter_actions(void);
> +extern void filter_syscall(struct tcb *);
> +extern void parse_qualify_filter(const char *);
>
> #define DECL_IOCTL(name) \
> extern int \
> diff --git a/filter.c b/filter.c
> new file mode 100644
> index 0000000..1f2d2eb
> --- /dev/null
> +++ b/filter.c
> @@ -0,0 +1,147 @@
> +/*
> + * 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 <ctype.h>
> +#include "filter.h"
> +
> +#define DECL_FILTER(name) \
> +extern void* \
> +parse_ ## name ## _filter(const char *, const char *const); \
> +extern bool \
> +run_ ## name ## _filter(struct tcb *, void *); \
> +extern void \
> +free_ ## name ## _filter(void *)
> +DECL_FILTER(syscall);
> +DECL_FILTER(fd);
> +DECL_FILTER(path);
> +#undef DECL_FILTER
> +
> +#define FILTER_TYPE(name) \
> +{#name, sizeof(#name) - 1, parse_ ## name ## _filter, \
> + run_ ## name ## _filter, free_ ## name ## _filter}
> +
> +static const struct filter_type {
> + const char *name;
> + const size_t name_len;
> + void *(*parse_filter)(const char *, const char *const);
> + bool (*run_filter)(struct tcb *, void *);
> + void (*free_priv_data)(void *);
> +} filter_types[] = {
> + FILTER_TYPE(syscall),
> + FILTER_TYPE(fd)
> +};
> +
> +#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++) {
> + const char *name = filter_types[i].name;
> + const size_t len = filter_types[i].name_len;
> + if (!strncmp(name, str, len) && !isalpha(str[len])) {
> + 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);
> + if (!type)
> + return NULL;
> + *filters = xreallocarray(*filters, ++(*nfilters),
> + sizeof(struct filter));
> + struct filter *filter = &((*filters)[*nfilters - 1]);
> + filter->type = type;
> + return filter;
> +}
> +
> +void
> +parse_filter(struct filter *filter, const char *str, const char *const name)
> +{
> + filter->_priv_data = filter->type->parse_filter(str, name);
> +}
> +
> +static bool
> +run_filter(struct tcb *tcp, struct filter *filter)
> +{
> + return filter->type->run_filter(tcp, filter->_priv_data);
> +}
> +
> +bool *
> +run_filters(struct tcb *tcp, struct filter *filters, unsigned int nfilters)
> +{
> + bool *variables = xcalloc(nfilters, sizeof(bool));
> + unsigned int i;
> + for (i = 0; i < nfilters; ++i) {
> + variables[i] = run_filter(tcp, &filters[i]);
> + }
> + return variables;
> +}
> +
> +void
> +free_filter(struct filter *filter)
> +{
> + if (!filter)
> + return;
> + filter->type->free_priv_data(filter->_priv_data);
> +}
> +
> +void *
> +get_filter_priv_data(struct filter *filter)
> +{
> + return filter ? filter->_priv_data : NULL;
> +}
> +
> +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 i;
> + for (i = 0; i < *nfilters - 1; ++i) {
> + free_filter(*filters + i);
> + }
> + **filters = (*filters)[*nfilters - 1];
> + *filters = xreallocarray(*filters, 1, sizeof(struct filter));
> + *nfilters = 1;
> +}
> diff --git a/filter.h b/filter.h
> index a798199..ed435c8 100644
> --- a/filter.h
> +++ b/filter.h
> @@ -28,11 +28,37 @@
> # define STRACE_FILTER_H
> # include "defs.h"
>
> +struct filter;
> +
> +struct filter_action;
> +
> +struct bool_expression;
> +
> +bool is_empty(const struct number_set *);
> +
> +extern bool is_traced(struct tcb *);
> +
> typedef int (*string_to_uint_func)(const char *);
> +void parse_set(const char *const, struct number_set *const,
> + string_to_uint_func, const char *const);
> +
> +struct filter* add_filter_to_array(struct filter **, unsigned int *nfilters,
> + const char *name);
> +void parse_filter(struct filter *, const char *str, const char *const name);
> +bool *run_filters(struct tcb *, struct filter *, unsigned int);
> +void free_filter(struct filter *);
> +void *get_filter_priv_data(struct filter *);
> +void set_filter_priv_data(struct filter *, void *);
> +void set_filters_qualify_mode(struct filter **, unsigned int *nfilters);
> +
> +struct filter *create_filter(struct filter_action *, const char *name);
> +void set_qualify_mode(struct filter_action *);
> +struct filter_action *find_or_add_action(const char *);
> +void *get_filter_action_priv_data(struct filter_action *);
> +void set_filter_action_priv_data(struct filter_action *, void *);
> +
> +struct bool_expression *create_expression();
> +void set_expression_qualify_mode(struct bool_expression *);
> +bool run_expression(struct bool_expression *, unsigned int, bool *);
>
> -void add_number_to_set(const unsigned int, struct number_set *const);
> -void qualify_tokens(const char *const, struct number_set *const,
> - string_to_uint_func, const char *const);
> -void qualify_syscall_tokens(const char *const, struct number_set *const,
> - const char *const);
> #endif
> diff --git a/filter_action.c b/filter_action.c
> new file mode 100644
> index 0000000..f71f140
> --- /dev/null
> +++ b/filter_action.c
> @@ -0,0 +1,203 @@
> +/*
> + * 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 <ctype.h>
> +#include "filter.h"
> +
> +#define DECL_FILTER_ACTION(name) \
> +extern void \
> +apply_ ## name(struct tcb *, void *)
> +
> +DECL_FILTER_ACTION(trace);
> +DECL_FILTER_ACTION(inject);
> +DECL_FILTER_ACTION(read);
> +DECL_FILTER_ACTION(write);
> +DECL_FILTER_ACTION(raw);
> +DECL_FILTER_ACTION(abbrev);
> +DECL_FILTER_ACTION(verbose);
> +
> +#undef DECL_FILTER_ACTION
> +
> +#define DECL_FILTER_ACTION_PARSER(name) \
> +extern void * \
> +parse_ ## name(const char *); \
> +extern void \
> +free_ ## name(void *)
> +
> +DECL_FILTER_ACTION_PARSER(null);
> +DECL_FILTER_ACTION_PARSER(inject);
> +
> +#undef DECL_FILTER_ACTION_PARSER
> +
> +#define FILTER_ACTION_TYPE(NAME, PRIORITY, PARSER, PREFILTER)
> \
> +{#NAME, sizeof(#NAME) - 1,PRIORITY, parse_ ## PARSER, free_ ## PARSER,
> \
> + PREFILTER, apply_ ## NAME}
> +
> +static const struct filter_action_type {
> + const char *name;
> + const size_t name_len;
> + unsigned int priority;
> + void *(*parse_args)(const char *);
> + void (*free_priv_data)(void *);
> + bool (*prefilter)(struct tcb *);
> + void (*apply)(struct tcb *, void *);
> +} action_types[] = {
> + FILTER_ACTION_TYPE(trace, 2, null, NULL),
> + FILTER_ACTION_TYPE(inject, 2, inject, NULL),
> + FILTER_ACTION_TYPE(read, 1, null, is_traced),
> + FILTER_ACTION_TYPE(write, 1, null, is_traced),
> + FILTER_ACTION_TYPE(raw, 1, null, is_traced),
> + FILTER_ACTION_TYPE(abbrev, 1, null, is_traced),
> + FILTER_ACTION_TYPE(verbose, 1, null, is_traced)
> +};
> +
> +#undef FILTER_ACTION_TYPE
> +
> +struct filter_action {
> + 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 int
> +compare_action_priority(const void *a, const void *b)
> +{
> + unsigned int priority_a = ((struct filter_action *)a)->type->priority;
> + unsigned int priority_b = ((struct filter_action *)b)->type->priority;
> + return (priority_a > priority_b) ? -1 :
> + (priority_a < priority_b) ? 1 : 0;
> +}
> +
> +void
> +sort_filter_actions(void)
> +{
> + qsort(filter_actions, nfilter_actions, sizeof(struct filter_action),
> + &compare_action_priority);
> +}
> +
> +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) {
> + const char *name = action_types[i].name;
> + const size_t len = action_types[i].name_len;
> + if (!strncmp(name, str, len) && !isalpha(str[len])) {
> + return &action_types[i];
> + }
> + }
> + return NULL;
> +}
> +
> +static struct filter_action *
> +add_action(const char *name)
> +{
> + const struct filter_action_type *type = lookup_filter_action_type(name);
> + if (!type)
> + error_msg_and_die("invalid filter action '%s'", name);
> + filter_actions = xreallocarray(filter_actions, ++nfilter_actions,
> + sizeof(struct filter_action));
> + struct filter_action *action = &filter_actions[nfilter_actions - 1];
> + memset(action, 0, sizeof(*action));
> + 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);
> + if (!type)
> + error_msg_and_die("invalid filter action '%s'", name);
> + if (type->parse_args != &parse_null)
> + return add_action(name);
> + unsigned int i;
> + for (i = 0; i < nfilter_actions; i++) {
> + if (filter_actions[i].type == type)
> + return &filter_actions[i];
> + }
> + return add_action(name);
> +}
> +
> +static void
> +run_filter_action(struct tcb *tcp, struct filter_action *action)
> +{
> + if (action->type->prefilter && !action->type->prefilter(tcp))
> + return;
> + bool *variables = run_filters(tcp, action->filters, action->nfilters);
> + bool res = run_expression(action->expr, action->nfilters, variables);
> + free(variables);
> + if (res) {
> + action->type->apply(tcp, action->_priv_data);
> + }
> +}
> +
> +struct filter *
> +create_filter(struct filter_action *action, const char *name)
> +{
> + if (!action)
> + error_msg_and_die("invalid filter action");
> + return add_filter_to_array(&action->filters,
> + &action->nfilters, name);
> +}
> +
> +void
> +set_qualify_mode(struct filter_action *action)
> +{
> + if ((!action) || action->nfilters == 0)
> + error_msg_and_die("invalid filter action");
> + set_filters_qualify_mode(&action->filters, &action->nfilters);
> + set_expression_qualify_mode(action->expr);
> +}
> +
> +void
> +filter_syscall(struct tcb *tcp)
> +{
> + unsigned int i;
> + for (i = 0; i < nfilter_actions; i++) {
> + run_filter_action(tcp, &filter_actions[i]);
> + }
> +}
> +
> +void *
> +get_filter_action_priv_data(struct filter_action *action)
> +{
> + return action ? action->_priv_data : NULL;
> +}
> +
> +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 0000000..ca02280
> --- /dev/null
> +++ b/filter_expression.c
> @@ -0,0 +1,131 @@
> +/*
> + * 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"
> +
> +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)
> +{
> + struct bool_expression *expr = xmalloc(sizeof(struct bool_expression));
> + memset(expr, 0, sizeof(struct bool_expression));
I think you should use xcalloc here.
> + return expr;
> +}
> +
> +static void
> +reallocate_expression(struct bool_expression *const expr, const unsigned int
> new_ntokens)
> +{
> + if (new_ntokens <= expr->ntokens)
> + return;
> + expr->tokens = xreallocarray(expr->tokens, new_ntokens,
> + sizeof(*expr->tokens));
> + memset(expr->tokens + expr->ntokens, 0,
> + sizeof(*expr->tokens) * (new_ntokens - expr->ntokens));
> + expr->ntokens = new_ntokens;
> +}
> +
> +#define STACK_SIZE 32
> +static bool stack[STACK_SIZE];
> +
> +void
> +set_expression_qualify_mode(struct bool_expression *expr)
> +{
> + if (!expr)
> + error_msg_and_die("invalid expression");
> + reallocate_expression(expr, 1);
> + expr->tokens[0].type = TOK_VARIABLE;
> + expr->tokens[0].data.variable_id = 0;
> +}
> +
> +bool
> +run_expression(struct bool_expression *expr,
> + unsigned int variables_num, bool *variables)
> +{
> + /* Current stack index */
> + unsigned int index = 0;
> + struct expression_token *tok = expr->tokens;
> + struct expression_token *const tok_end = expr->tokens + expr->ntokens;
> + for (; tok != tok_end; ++tok) {
> + switch (tok->type) {
> + case TOK_VARIABLE:
> + if (index == STACK_SIZE)
> + error_msg_and_die("stack overflow");
> + if (tok->data.variable_id >= variables_num)
> + error_msg_and_die("corrupted filter "
> + "expression");
> + stack[index] = variables[tok->data.variable_id];
> + index++;
> + break;
> + case TOK_OPERATOR:
> + switch (tok->data.operator_id) {
> + case OP_NOT:
> + if (index == 0)
> + error_msg_and_die("corrupted filter "
> + "expression");
> + stack[index - 1] = !stack[index - 1];
> + break;
> + case OP_AND:
> + if (index < 2)
> + error_msg_and_die("corrupted filter "
> + "expression");
> + stack[index - 2] = stack[index - 2]
> + && stack[index - 1];
> + --index;
> + break;
> + case OP_OR:
> + if (index < 2)
> + error_msg_and_die("corrupted filter "
> + "expression");
> + stack[index - 2] = stack[index - 2]
> + || stack[index - 1];
> + --index;
> + break;
> + }
> + }
> + }
> + if (index != 1)
> + error_msg_and_die("corrupted filter expression");
> + return stack[0];
> +}
> diff --git a/filter_qualify.c b/filter_qualify.c
> index e23a9f1..6020ce8 100644
> --- a/filter_qualify.c
> +++ b/filter_qualify.c
> @@ -25,13 +25,11 @@
> * (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 "nsig.h"
> #include "filter.h"
>
> typedef unsigned int number_slot_t;
> -#define BITS_PER_SLOT (sizeof(number_slot_t) * 8)
>
> struct number_set {
> number_slot_t *vec;
> @@ -39,16 +37,8 @@ struct number_set {
> bool not;
> };
>
> -struct number_set read_set;
> -struct number_set write_set;
> struct number_set signal_set;
>
> -static struct number_set abbrev_set[SUPPORTED_PERSONALITIES];
> -static struct number_set inject_set[SUPPORTED_PERSONALITIES];
> -static struct number_set raw_set[SUPPORTED_PERSONALITIES];
> -static struct number_set trace_set[SUPPORTED_PERSONALITIES];
> -static struct number_set verbose_set[SUPPORTED_PERSONALITIES];
> -
> static int
> find_errno_by_name(const char *name)
> {
> @@ -184,49 +174,67 @@ parse_error:
> }
>
> static void
> -qualify_read(const char *const str)
> +parse_read(const char *const str)
> {
> - 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, "descriptor");
> + set_qualify_mode(action);
> }
>
> static void
> -qualify_write(const char *const str)
> +parse_write(const char *const str)
> {
> - 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, "descriptor");
> + set_qualify_mode(action);
> }
>
> static void
> qualify_signals(const char *const str)
> {
> - qualify_tokens(str, &signal_set, sigstr_to_uint, "signal");
> + parse_set(str, &signal_set, sigstr_to_uint, "signal");
> }
>
> static void
> -qualify_trace(const char *const str)
> +parse_trace(const char *const str)
> {
> - 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, "system call");
> + set_qualify_mode(action);
> }
>
> static void
> -qualify_abbrev(const char *const str)
> +parse_abbrev(const char *const str)
> {
> - 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, "system call");
> + set_qualify_mode(action);
> }
>
> static void
> -qualify_verbose(const char *const str)
> +parse_verbose(const char *const str)
> {
> - 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, "system call");
> + set_qualify_mode(action);
> }
>
> static void
> -qualify_raw(const char *const str)
> +parse_raw(const char *const str)
> {
> - 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, "system call");
> + set_qualify_mode(action);
> }
>
> static void
> -qualify_inject_common(const char *const str,
> +parse_inject_common(const char *const str,
> const bool fault_tokens_only,
> const char *const description)
> {
> @@ -253,19 +261,23 @@ qualify_inject_common(const char *const str,
> }
> }
>
> - struct number_set tmp_set[SUPPORTED_PERSONALITIES];
> - memset(tmp_set, 0, sizeof(tmp_set));
> - qualify_syscall_tokens(name, tmp_set, description);
> + struct filter_action *action = find_or_add_action("inject");
> + struct filter *filter = create_filter(action, "syscall");
> + parse_filter(filter, name, description);
> + set_qualify_mode(action);
>
> free(buf);
> -
> + const struct number_set *tmp_set = (const struct number_set *)
This cast is useless.
> + get_filter_priv_data(filter);
> + struct inject_opts **inject_vec = xcalloc(SUPPORTED_PERSONALITIES,
> + sizeof(struct inject_opts *));
> /*
> * Initialize inject_vec accourding to tmp_set.
> - * Merge tmp_set into inject_set.
> */
> +
> unsigned int p;
> for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
> - if (!tmp_set[p].nslots && !tmp_set[p].not) {
> + if (is_empty(&tmp_set[p])) {
> continue;
> }
>
> @@ -277,54 +289,53 @@ qualify_inject_common(const char *const str,
> unsigned int i;
> for (i = 0; i < nsyscall_vec[p]; ++i) {
> if (is_number_in_set(i, &tmp_set[p])) {
> - add_number_to_set(i, &inject_set[p]);
> inject_vec[p][i] = opts;
> }
> }
> -
> - free(tmp_set[p].vec);
> }
> + set_filter_action_priv_data(action, inject_vec);
> }
>
> static void
> -qualify_fault(const char *const str)
> +parse_fault(const char *const str)
> {
> - qualify_inject_common(str, true, "fault argument");
> + parse_inject_common(str, true, "fault argument");
> }
>
> static void
> -qualify_inject(const char *const str)
> +parse_inject(const char *const str)
> {
> - qualify_inject_common(str, false, "inject argument");
> + parse_inject_common(str, false, "inject argument");
> }
>
> static const struct qual_options {
> const char *name;
> void (*qualify)(const char *);
> } qual_options[] = {
> - { "trace", qualify_trace },
> - { "t", qualify_trace },
> - { "abbrev", qualify_abbrev },
> - { "a", qualify_abbrev },
> - { "verbose", qualify_verbose },
> - { "v", qualify_verbose },
> - { "raw", qualify_raw },
> - { "x", qualify_raw },
> + { "trace", parse_trace },
> + { "t", parse_trace },
> + { "abbrev", parse_abbrev },
> + { "a", parse_abbrev },
> + { "verbose", parse_verbose },
> + { "v", parse_verbose },
> + { "raw", parse_raw },
> + { "x", parse_raw },
> { "signal", qualify_signals },
> { "signals", qualify_signals },
> { "s", qualify_signals },
> - { "read", qualify_read },
> - { "reads", qualify_read },
> - { "r", qualify_read },
> - { "write", qualify_write },
> - { "writes", qualify_write },
> - { "w", qualify_write },
> - { "fault", qualify_fault },
> - { "inject", qualify_inject },
> + { "read", parse_read },
> + { "reads", parse_read },
> + { "r", parse_read },
> + { "write", parse_write },
> + { "writes", parse_write },
> + { "w", parse_write },
> + { "fault", parse_fault },
> + { "inject", parse_inject },
> };
>
> +
> void
> -qualify(const char *str)
> +parse_qualify_filter(const char *str)
> {
> const struct qual_options *opt = qual_options;
> unsigned int i;
> @@ -340,21 +351,5 @@ qualify(const char *str)
> opt = &qual_options[i];
> break;
> }
> -
> opt->qualify(str);
> }
> -
> -unsigned int
> -qual_flags(const unsigned int scno)
> -{
> - return (is_number_in_set(scno, &trace_set[current_personality])
> - ? QUAL_TRACE : 0)
> - | (is_number_in_set(scno, &abbrev_set[current_personality])
> - ? QUAL_ABBREV : 0)
> - | (is_number_in_set(scno, &verbose_set[current_personality])
> - ? QUAL_VERBOSE : 0)
> - | (is_number_in_set(scno, &raw_set[current_personality])
> - ? QUAL_RAW : 0)
> - | (is_number_in_set(scno, &inject_set[current_personality])
> - ? QUAL_INJECT : 0);
> -}
> diff --git a/strace.c b/strace.c
> index 614ab9e..e48ed76 100644
> --- a/strace.c
> +++ b/strace.c
> @@ -822,10 +822,6 @@ droptcb(struct tcb *tcp)
> if (tcp->pid == 0)
> return;
>
> - int p;
> - for (p = 0; p < SUPPORTED_PERSONALITIES; ++p)
> - free(tcp->inject_vec[p]);
> -
> free_tcb_priv_data(tcp);
>
> #ifdef USE_LIBUNWIND
> @@ -1626,13 +1622,13 @@ init(int argc, char *argv[])
> shared_log = stderr;
> set_sortby(DEFAULT_SORTBY);
> set_personality(DEFAULT_PERSONALITY);
> - qualify("trace=all");
> - qualify("abbrev=all");
> - qualify("verbose=all");
> + parse_qualify_filter("trace=all");
> + parse_qualify_filter("abbrev=all");
> + parse_qualify_filter("verbose=all");
> #if DEFAULT_QUAL_FLAGS != (QUAL_TRACE | QUAL_ABBREV | QUAL_VERBOSE)
> # error Bug in DEFAULT_QUAL_FLAGS
> #endif
> - qualify("signal=all");
> + parse_qualify_filter("signal=all");
> while ((c = getopt(argc, argv,
> "+b:cCdfFhiqrtTvVwxyz"
> #ifdef USE_LIBUNWIND
> @@ -1699,7 +1695,7 @@ init(int argc, char *argv[])
> show_fd_path++;
> break;
> case 'v':
> - qualify("abbrev=none");
> + parse_qualify_filter("abbrev=none");
> break;
> case 'V':
> print_version();
> @@ -1714,7 +1710,7 @@ init(int argc, char *argv[])
> error_opt_arg(c, optarg);
> break;
> case 'e':
> - qualify(optarg);
> + parse_qualify_filter(optarg);
> break;
> case 'o':
> outfname = xstrdup(optarg);
> @@ -1762,6 +1758,8 @@ init(int argc, char *argv[])
> break;
> }
> }
> + sort_filter_actions();
> +
> argv += optind;
> /* argc -= optind; - no need, argc is not used below */
>
> @@ -2459,6 +2457,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 02626c7..b6e1ba3 100644
> --- a/syscall.c
> +++ b/syscall.c
> @@ -382,7 +382,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;
> @@ -422,7 +421,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;
> @@ -439,7 +437,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]));
> @@ -468,7 +465,7 @@ dumpio(struct tcb *tcp)
> if (fd < 0)
> return;
>
> - if (is_number_in_set(fd, &read_set)) {
> + if (tcp->qual_flg & QUAL_READ) {
> switch (tcp->s_ent->sen) {
> case SEN_read:
> case SEN_pread:
> @@ -491,7 +488,7 @@ dumpio(struct tcb *tcp)
> return;
> }
> }
> - if (is_number_in_set(fd, &write_set)) {
> + if (tcp->qual_flg & QUAL_WRITE) {
> switch (tcp->s_ent->sen) {
> case SEN_write:
> case SEN_pwrite:
> @@ -577,28 +574,10 @@ 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)
> -{
> - return (scno_in_range(tcp->scno) &&
> tcp->inject_vec[current_personality])
> - ? &tcp->inject_vec[current_personality][tcp->scno] : NULL;
> -}
> -
> -
> 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);
> + struct inject_opts *opts = tcp->inject_opts;
>
> if (!opts || opts->first == 0)
> return 0;
> @@ -621,7 +600,7 @@ tamper_with_syscall_entering(struct tcb *tcp, unsigned
> int *signo)
> static long
> tamper_with_syscall_exiting(struct tcb *tcp)
> {
> - struct inject_opts *opts = tcb_inject_opts(tcp);
> + struct inject_opts *opts = tcp->inject_opts;
>
> if (!opts)
> return 0;
> @@ -1258,7 +1237,7 @@ get_scno(struct tcb *tcp)
>
> if (scno_is_valid(tcp->scno)) {
> tcp->s_ent = &sysent[tcp->scno];
> - tcp->qual_flg = qual_flags(tcp->scno);
> + tcp->qual_flg = 0;
> } else {
> struct sysent_buf *s = xcalloc(1, sizeof(*s));
>
> --
> 2.1.4
>
>
> ------------------------------------------------------------------------------
> 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
------------------------------------------------------------------------------
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
