[PATCH v2 1/6] Split qualify.c into basic_filters.c and filter_qualify.c

Nikolay Marchuk marchuk.nikolay.a at gmail.com
Tue Jun 27 07:48:43 UTC 2017


* basic_filters.c: New file, part of qualify.c.
* filter_qualify.c: Likewise.
* filter.h: New file.
* qualify.c: Remove.
* Makefile.am (strace_SOURCES): Add new files, remove qualify.c.
---
 Makefile.am      |   4 +-
 basic_filters.c  | 375 ++++++++++++++++++++++++++++++
 filter.h         |  38 +++
 filter_qualify.c | 360 ++++++++++++++++++++++++++++
 qualify.c        | 697 -------------------------------------------------------
 5 files changed, 776 insertions(+), 698 deletions(-)
 create mode 100644 basic_filters.c
 create mode 100644 filter.h
 create mode 100644 filter_qualify.c
 delete mode 100644 qualify.c

diff --git a/Makefile.am b/Makefile.am
index 76be3ca..4f5ebfb 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -86,6 +86,7 @@ strace_SOURCES =	\
 	affinity.c	\
 	aio.c		\
 	alpha.c		\
+	basic_filters.c	\
 	bjm.c		\
 	block.c		\
 	bpf.c		\
@@ -124,6 +125,8 @@ strace_SOURCES =	\
 	fetch_struct_statfs.c \
 	file_handle.c	\
 	file_ioctl.c	\
+	filter_qualify.c \
+	filter.h	\
 	fs_x_ioctl.c	\
 	flock.c		\
 	flock.h		\
@@ -210,7 +213,6 @@ strace_SOURCES =	\
 	process_vm.c	\
 	ptp.c		\
 	ptrace.h	\
-	qualify.c	\
 	quota.c		\
 	readahead.c	\
 	readlink.c	\
diff --git a/basic_filters.c b/basic_filters.c
new file mode 100644
index 0000000..316b733
--- /dev/null
+++ b/basic_filters.c
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) 2016 Dmitry V. Levin <ldv at altlinux.org>
+ * Copyright (c) 2016-2017 The strace developers.
+ * 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 <regex.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;
+	unsigned int nslots;
+	bool not;
+};
+
+static void
+number_setbit(const unsigned int i, number_slot_t *const vec)
+{
+	vec[i / BITS_PER_SLOT] |= (number_slot_t) 1 << (i % BITS_PER_SLOT);
+}
+
+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));
+}
+
+static void
+reallocate_number_set(struct number_set *const set, const unsigned int new_nslots)
+{
+	if (new_nslots <= set->nslots)
+		return;
+	set->vec = xreallocarray(set->vec, new_nslots, sizeof(*set->vec));
+	memset(set->vec + set->nslots, 0,
+	       sizeof(*set->vec) * (new_nslots - set->nslots));
+	set->nslots = new_nslots;
+}
+
+void
+add_number_to_set(const unsigned int number, struct number_set *const set)
+{
+	reallocate_number_set(set, number / BITS_PER_SLOT + 1);
+	number_setbit(number, set->vec);
+}
+
+bool
+is_number_in_set(const unsigned int number, const struct number_set *const set)
+{
+	return ((number / BITS_PER_SLOT < set->nslots)
+		&& number_isset(number, set->vec)) ^ set->not;
+}
+
+static bool
+qualify_syscall_number(const char *s, struct number_set *set)
+{
+	int n = string_to_uint(s);
+	if (n < 0)
+		return false;
+
+	unsigned int p;
+	bool done = false;
+
+	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+		if ((unsigned) n >= nsyscall_vec[p]) {
+			continue;
+		}
+		add_number_to_set(n, &set[p]);
+		done = true;
+	}
+
+	return done;
+}
+
+static void
+regerror_msg_and_die(int errcode, const regex_t *preg,
+		     const char *str, const char *pattern)
+{
+	char buf[512];
+
+	regerror(errcode, preg, buf, sizeof(buf));
+	error_msg_and_die("%s: %s: %s", str, pattern, buf);
+}
+
+static bool
+qualify_syscall_regex(const char *s, struct number_set *set)
+{
+	regex_t preg;
+	int rc;
+
+	if ((rc = regcomp(&preg, s, REG_EXTENDED | REG_NOSUB)) != 0)
+		regerror_msg_and_die(rc, &preg, "regcomp", s);
+
+	unsigned int p;
+	bool found = false;
+	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+		unsigned int i;
+
+		for (i = 0; i < nsyscall_vec[p]; ++i) {
+			if (!sysent_vec[p][i].sys_name)
+				continue;
+			rc = regexec(&preg, sysent_vec[p][i].sys_name,
+				     0, NULL, 0);
+			if (rc == REG_NOMATCH)
+				continue;
+			else if (rc)
+				regerror_msg_and_die(rc, &preg, "regexec", s);
+			add_number_to_set(i, &set[p]);
+			found = true;
+		}
+	}
+
+	regfree(&preg);
+	return found;
+}
+
+static unsigned int
+lookup_class(const char *s)
+{
+	static const struct {
+		const char *name;
+		unsigned int value;
+	} syscall_class[] = {
+		{ "desc",	TRACE_DESC	},
+		{ "file",	TRACE_FILE	},
+		{ "memory",	TRACE_MEMORY	},
+		{ "process",	TRACE_PROCESS	},
+		{ "signal",	TRACE_SIGNAL	},
+		{ "ipc",	TRACE_IPC	},
+		{ "network",	TRACE_NETWORK	},
+		{ "%desc",	TRACE_DESC	},
+		{ "%file",	TRACE_FILE	},
+		{ "%memory",	TRACE_MEMORY	},
+		{ "%process",	TRACE_PROCESS	},
+		{ "%signal",	TRACE_SIGNAL	},
+		{ "%ipc",	TRACE_IPC	},
+		{ "%network",	TRACE_NETWORK	},
+		{ "%stat",	TRACE_STAT	},
+		{ "%lstat",	TRACE_LSTAT	},
+		{ "%fstat",	TRACE_FSTAT	},
+		{ "%%stat",	TRACE_STAT_LIKE	},
+		{ "%statfs",	TRACE_STATFS	},
+		{ "%fstatfs",	TRACE_FSTATFS	},
+		{ "%%statfs",	TRACE_STATFS_LIKE	},
+	};
+
+	unsigned int i;
+	for (i = 0; i < ARRAY_SIZE(syscall_class); ++i) {
+		if (strcmp(s, syscall_class[i].name) == 0) {
+			return syscall_class[i].value;
+		}
+	}
+
+	return 0;
+}
+
+static bool
+qualify_syscall_class(const char *s, struct number_set *set)
+{
+	const unsigned int n = lookup_class(s);
+	if (!n)
+		return false;
+
+	unsigned int p;
+	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+		unsigned int i;
+
+		for (i = 0; i < nsyscall_vec[p]; ++i) {
+			if (!sysent_vec[p][i].sys_name
+			    || (sysent_vec[p][i].sys_flags & n) != n) {
+				continue;
+			}
+			add_number_to_set(i, &set[p]);
+		}
+	}
+
+	return true;
+}
+
+static bool
+qualify_syscall_name(const char *s, struct number_set *set)
+{
+	unsigned int p;
+	bool found = false;
+
+	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+		unsigned int i;
+
+		for (i = 0; i < nsyscall_vec[p]; ++i) {
+			if (!sysent_vec[p][i].sys_name
+			    || strcmp(s, sysent_vec[p][i].sys_name)) {
+				continue;
+			}
+			add_number_to_set(i, &set[p]);
+			found = true;
+		}
+	}
+
+	return found;
+}
+
+static bool
+qualify_syscall(const char *token, struct number_set *set)
+{
+	bool ignore_fail = false;
+
+	while (*token == '?') {
+		token++;
+		ignore_fail = true;
+	}
+	if (*token >= '0' && *token <= '9')
+		return qualify_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)
+	       || 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)
+{
+	/* Clear all sets. */
+	unsigned int p;
+	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+		if (set[p].nslots)
+			memset(set[p].vec, 0,
+			       sizeof(*set[p].vec) * set[p].nslots);
+		set[p].not = false;
+	}
+
+	/*
+	 * Each leading ! character means inversion
+	 * of the remaining specification.
+	 */
+	const char *s = str;
+handle_inversion:
+	while (*s == '!') {
+		for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
+			set[p].not = !set[p].not;
+		}
+		++s;
+	}
+
+	if (strcmp(s, "none") == 0) {
+		/*
+		 * No syscall numbers are added to sets.
+		 * Subsequent is_number_in_set invocations
+		 * will return set[p]->not.
+		 */
+		return;
+	} else if (strcmp(s, "all") == 0) {
+		s = "!none";
+		goto handle_inversion;
+	}
+
+	/*
+	 * Split the string into comma separated tokens.
+	 * For each token, call qualify_syscall that will take care
+	 * if adding appropriate syscall numbers to sets.
+	 * The absence of tokens or a negative return code
+	 * from qualify_syscall is a fatal error.
+	 */
+	char *copy = xstrdup(s);
+	char *saveptr = NULL;
+	const char *token;
+	bool done = false;
+
+	for (token = strtok_r(copy, ",", &saveptr); token;
+	     token = strtok_r(NULL, ",", &saveptr)) {
+		done = qualify_syscall(token, set);
+		if (!done) {
+			error_msg_and_die("invalid %s '%s'", name, token);
+		}
+	}
+
+	free(copy);
+
+	if (!done) {
+		error_msg_and_die("invalid %s '%s'", name, str);
+	}
+}
+
+/*
+ * Add numbers to SET according to STR specification.
+ */
+void
+qualify_tokens(const char *const str, struct number_set *const set,
+	       string_to_uint_func func, const char *const name)
+{
+	/* Clear the set. */
+	if (set->nslots)
+		memset(set->vec, 0, sizeof(*set->vec) * set->nslots);
+	set->not = false;
+
+	/*
+	 * Each leading ! character means inversion
+	 * of the remaining specification.
+	 */
+	const char *s = str;
+handle_inversion:
+	while (*s == '!') {
+		set->not = !set->not;
+		++s;
+	}
+
+	if (strcmp(s, "none") == 0) {
+		/*
+		 * No numbers are added to the set.
+		 * Subsequent is_number_in_set invocations will return set->not.
+		 */
+		return;
+	} else if (strcmp(s, "all") == 0) {
+		s = "!none";
+		goto handle_inversion;
+	}
+
+	/*
+	 * Split the string into comma separated tokens.
+	 * For each token, find out the corresponding number
+	 * by calling FUNC, and add that number to the set.
+	 * The absence of tokens or a negative answer
+	 * from FUNC is a fatal error.
+	 */
+	char *copy = xstrdup(s);
+	char *saveptr = NULL;
+	const char *token;
+	int number = -1;
+
+	for (token = strtok_r(copy, ",", &saveptr); token;
+	     token = strtok_r(NULL, ",", &saveptr)) {
+		number = func(token);
+		if (number < 0) {
+			error_msg_and_die("invalid %s '%s'", name, token);
+		}
+
+		add_number_to_set(number, set);
+	}
+
+	free(copy);
+
+	if (number < 0) {
+		error_msg_and_die("invalid %s '%s'", name, str);
+	}
+}
diff --git a/filter.h b/filter.h
new file mode 100644
index 0000000..a798199
--- /dev/null
+++ b/filter.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2017 Nikolay Marchuk <marchuk.nikolay.a at 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.
+ */
+#ifndef STRACE_FILTER_H
+# define STRACE_FILTER_H
+# include "defs.h"
+
+typedef int (*string_to_uint_func)(const char *);
+
+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_qualify.c b/filter_qualify.c
new file mode 100644
index 0000000..e23a9f1
--- /dev/null
+++ b/filter_qualify.c
@@ -0,0 +1,360 @@
+/*
+ * Copyright (c) 2016 Dmitry V. Levin <ldv at altlinux.org>
+ * Copyright (c) 2016-2017 The strace developers.
+ * 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 "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;
+	unsigned int nslots;
+	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)
+{
+	unsigned int i;
+
+	for (i = 1; i < nerrnos; ++i) {
+		if (errnoent[i] && (strcasecmp(name, errnoent[i]) == 0))
+			return i;
+	}
+
+	return -1;
+}
+
+static int
+sigstr_to_uint(const char *s)
+{
+	int i;
+
+	if (*s >= '0' && *s <= '9')
+		return string_to_uint_upto(s, 255);
+
+	if (strncasecmp(s, "SIG", 3) == 0)
+		s += 3;
+
+	for (i = 0; i <= 255; ++i) {
+		const char *name = signame(i);
+
+		if (strncasecmp(name, "SIG", 3) != 0)
+			continue;
+
+		name += 3;
+
+		if (strcasecmp(name, s) != 0)
+			continue;
+
+		return i;
+	}
+
+	return -1;
+}
+
+static bool
+parse_inject_token(const char *const token, struct inject_opts *const fopts,
+		   const bool fault_tokens_only)
+{
+	const char *val;
+	int intval;
+
+	if ((val = STR_STRIP_PREFIX(token, "when=")) != token) {
+		/*
+		 *	== 1+1
+		 * F	== F+0
+		 * F+	== F+1
+		 * F+S
+		 */
+		char *end;
+		intval = string_to_uint_ex(val, &end, 0xffff, "+");
+		if (intval < 1)
+			return false;
+
+		fopts->first = intval;
+
+		if (*end) {
+			val = end + 1;
+			if (*val) {
+				/* F+S */
+				intval = string_to_uint_upto(val, 0xffff);
+				if (intval < 1)
+					return false;
+				fopts->step = intval;
+			} else {
+				/* F+ == F+1 */
+				fopts->step = 1;
+			}
+		} else {
+			/* F == F+0 */
+			fopts->step = 0;
+		}
+	} else if ((val = STR_STRIP_PREFIX(token, "error=")) != token) {
+		if (fopts->rval != INJECT_OPTS_RVAL_DEFAULT)
+			return false;
+		intval = string_to_uint_upto(val, MAX_ERRNO_VALUE);
+		if (intval < 0)
+			intval = find_errno_by_name(val);
+		if (intval < 1)
+			return false;
+		fopts->rval = -intval;
+	} else if (!fault_tokens_only
+		   && (val = STR_STRIP_PREFIX(token, "retval=")) != token) {
+		if (fopts->rval != INJECT_OPTS_RVAL_DEFAULT)
+			return false;
+		intval = string_to_uint(val);
+		if (intval < 0)
+			return false;
+		fopts->rval = intval;
+	} else if (!fault_tokens_only
+		   && (val = STR_STRIP_PREFIX(token, "signal=")) != token) {
+		intval = sigstr_to_uint(val);
+		if (intval < 1 || intval > NSIG_BYTES * 8)
+			return false;
+		fopts->signo = intval;
+	} else {
+		return false;
+	}
+
+	return true;
+}
+
+static char *
+parse_inject_expression(const char *const s, char **buf,
+			struct inject_opts *const fopts,
+			const bool fault_tokens_only)
+{
+	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;
+	}
+
+	if (name)
+		return name;
+
+parse_error:
+	free(*buf);
+	return *buf = NULL;
+}
+
+static void
+qualify_read(const char *const str)
+{
+	qualify_tokens(str, &read_set, string_to_uint, "descriptor");
+}
+
+static void
+qualify_write(const char *const str)
+{
+	qualify_tokens(str, &write_set, string_to_uint, "descriptor");
+}
+
+static void
+qualify_signals(const char *const str)
+{
+	qualify_tokens(str, &signal_set, sigstr_to_uint, "signal");
+}
+
+static void
+qualify_trace(const char *const str)
+{
+	qualify_syscall_tokens(str, trace_set, "system call");
+}
+
+static void
+qualify_abbrev(const char *const str)
+{
+	qualify_syscall_tokens(str, abbrev_set, "system call");
+}
+
+static void
+qualify_verbose(const char *const str)
+{
+	qualify_syscall_tokens(str, verbose_set, "system call");
+}
+
+static void
+qualify_raw(const char *const str)
+{
+	qualify_syscall_tokens(str, raw_set, "system call");
+}
+
+static void
+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[SUPPORTED_PERSONALITIES];
+	memset(tmp_set, 0, sizeof(tmp_set));
+	qualify_syscall_tokens(name, tmp_set, description);
+
+	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 (!tmp_set[p].nslots && !tmp_set[p].not) {
+			continue;
+		}
+
+		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(i, &tmp_set[p])) {
+				add_number_to_set(i, &inject_set[p]);
+				inject_vec[p][i] = opts;
+			}
+		}
+
+		free(tmp_set[p].vec);
+	}
+}
+
+static void
+qualify_fault(const char *const str)
+{
+	qualify_inject_common(str, true, "fault argument");
+}
+
+static void
+qualify_inject(const char *const str)
+{
+	qualify_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	},
+	{ "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	},
+};
+
+void
+qualify(const char *str)
+{
+	const struct qual_options *opt = qual_options;
+	unsigned int i;
+
+	for (i = 0; i < ARRAY_SIZE(qual_options); ++i) {
+		const char *name = qual_options[i].name;
+		const size_t len = strlen(name);
+		const char *val = str_strip_prefix_len(str, name, len);
+
+		if (val == str || *val != '=')
+			continue;
+		str = val + 1;
+		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/qualify.c b/qualify.c
deleted file mode 100644
index 3df4805..0000000
--- a/qualify.c
+++ /dev/null
@@ -1,697 +0,0 @@
-/*
- * Copyright (c) 2016 Dmitry V. Levin <ldv at altlinux.org>
- * Copyright (c) 2016-2017 The strace developers.
- * 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 "nsig.h"
-#include <regex.h>
-
-typedef unsigned int number_slot_t;
-#define BITS_PER_SLOT (sizeof(number_slot_t) * 8)
-
-struct number_set {
-	number_slot_t *vec;
-	unsigned int nslots;
-	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 void
-number_setbit(const unsigned int i, number_slot_t *const vec)
-{
-	vec[i / BITS_PER_SLOT] |= (number_slot_t) 1 << (i % BITS_PER_SLOT);
-}
-
-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));
-}
-
-static void
-reallocate_number_set(struct number_set *const set, const unsigned int new_nslots)
-{
-	if (new_nslots <= set->nslots)
-		return;
-	set->vec = xreallocarray(set->vec, new_nslots, sizeof(*set->vec));
-	memset(set->vec + set->nslots, 0,
-	       sizeof(*set->vec) * (new_nslots - set->nslots));
-	set->nslots = new_nslots;
-}
-
-static void
-add_number_to_set(const unsigned int number, struct number_set *const set)
-{
-	reallocate_number_set(set, number / BITS_PER_SLOT + 1);
-	number_setbit(number, set->vec);
-}
-
-bool
-is_number_in_set(const unsigned int number, const struct number_set *const set)
-{
-	return ((number / BITS_PER_SLOT < set->nslots)
-		&& number_isset(number, set->vec)) ^ set->not;
-}
-
-typedef int (*string_to_uint_func)(const char *);
-
-/*
- * Add numbers to SET according to STR specification.
- */
-static void
-qualify_tokens(const char *const str, struct number_set *const set,
-	       string_to_uint_func func, const char *const name)
-{
-	/* Clear the set. */
-	if (set->nslots)
-		memset(set->vec, 0, sizeof(*set->vec) * set->nslots);
-	set->not = false;
-
-	/*
-	 * Each leading ! character means inversion
-	 * of the remaining specification.
-	 */
-	const char *s = str;
-handle_inversion:
-	while (*s == '!') {
-		set->not = !set->not;
-		++s;
-	}
-
-	if (strcmp(s, "none") == 0) {
-		/*
-		 * No numbers are added to the set.
-		 * Subsequent is_number_in_set invocations will return set->not.
-		 */
-		return;
-	} else if (strcmp(s, "all") == 0) {
-		s = "!none";
-		goto handle_inversion;
-	}
-
-	/*
-	 * Split the string into comma separated tokens.
-	 * For each token, find out the corresponding number
-	 * by calling FUNC, and add that number to the set.
-	 * The absence of tokens or a negative answer
-	 * from FUNC is a fatal error.
-	 */
-	char *copy = xstrdup(s);
-	char *saveptr = NULL;
-	const char *token;
-	int number = -1;
-
-	for (token = strtok_r(copy, ",", &saveptr); token;
-	     token = strtok_r(NULL, ",", &saveptr)) {
-		number = func(token);
-		if (number < 0) {
-			error_msg_and_die("invalid %s '%s'", name, token);
-		}
-
-		add_number_to_set(number, set);
-	}
-
-	free(copy);
-
-	if (number < 0) {
-		error_msg_and_die("invalid %s '%s'", name, str);
-	}
-}
-
-static int
-sigstr_to_uint(const char *s)
-{
-	int i;
-
-	if (*s >= '0' && *s <= '9')
-		return string_to_uint_upto(s, 255);
-
-	if (strncasecmp(s, "SIG", 3) == 0)
-		s += 3;
-
-	for (i = 0; i <= 255; ++i) {
-		const char *name = signame(i);
-
-		if (strncasecmp(name, "SIG", 3) != 0)
-			continue;
-
-		name += 3;
-
-		if (strcasecmp(name, s) != 0)
-			continue;
-
-		return i;
-	}
-
-	return -1;
-}
-
-static bool
-qualify_syscall_number(const char *s, struct number_set *set)
-{
-	int n = string_to_uint(s);
-	if (n < 0)
-		return false;
-
-	unsigned int p;
-	bool done = false;
-
-	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-		if ((unsigned) n >= nsyscall_vec[p]) {
-			continue;
-		}
-		add_number_to_set(n, &set[p]);
-		done = true;
-	}
-
-	return done;
-}
-
-static void
-regerror_msg_and_die(int errcode, const regex_t *preg,
-		     const char *str, const char *pattern)
-{
-	char buf[512];
-
-	regerror(errcode, preg, buf, sizeof(buf));
-	error_msg_and_die("%s: %s: %s", str, pattern, buf);
-}
-
-static bool
-qualify_syscall_regex(const char *s, struct number_set *set)
-{
-	regex_t preg;
-	int rc;
-
-	if ((rc = regcomp(&preg, s, REG_EXTENDED | REG_NOSUB)) != 0)
-		regerror_msg_and_die(rc, &preg, "regcomp", s);
-
-	unsigned int p;
-	bool found = false;
-	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-		unsigned int i;
-
-		for (i = 0; i < nsyscall_vec[p]; ++i) {
-			if (!sysent_vec[p][i].sys_name)
-				continue;
-			rc = regexec(&preg, sysent_vec[p][i].sys_name,
-				     0, NULL, 0);
-			if (rc == REG_NOMATCH)
-				continue;
-			else if (rc)
-				regerror_msg_and_die(rc, &preg, "regexec", s);
-			add_number_to_set(i, &set[p]);
-			found = true;
-		}
-	}
-
-	regfree(&preg);
-	return found;
-}
-
-static unsigned int
-lookup_class(const char *s)
-{
-	static const struct {
-		const char *name;
-		unsigned int value;
-	} syscall_class[] = {
-		{ "desc",	TRACE_DESC	},
-		{ "file",	TRACE_FILE	},
-		{ "memory",	TRACE_MEMORY	},
-		{ "process",	TRACE_PROCESS	},
-		{ "signal",	TRACE_SIGNAL	},
-		{ "ipc",	TRACE_IPC	},
-		{ "network",	TRACE_NETWORK	},
-		{ "%desc",	TRACE_DESC	},
-		{ "%file",	TRACE_FILE	},
-		{ "%memory",	TRACE_MEMORY	},
-		{ "%process",	TRACE_PROCESS	},
-		{ "%signal",	TRACE_SIGNAL	},
-		{ "%ipc",	TRACE_IPC	},
-		{ "%network",	TRACE_NETWORK	},
-		{ "%stat",	TRACE_STAT	},
-		{ "%lstat",	TRACE_LSTAT	},
-		{ "%fstat",	TRACE_FSTAT	},
-		{ "%%stat",	TRACE_STAT_LIKE	},
-		{ "%statfs",	TRACE_STATFS	},
-		{ "%fstatfs",	TRACE_FSTATFS	},
-		{ "%%statfs",	TRACE_STATFS_LIKE	},
-	};
-
-	unsigned int i;
-	for (i = 0; i < ARRAY_SIZE(syscall_class); ++i) {
-		if (strcmp(s, syscall_class[i].name) == 0) {
-			return syscall_class[i].value;
-		}
-	}
-
-	return 0;
-}
-
-static bool
-qualify_syscall_class(const char *s, struct number_set *set)
-{
-	const unsigned int n = lookup_class(s);
-	if (!n)
-		return false;
-
-	unsigned int p;
-	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-		unsigned int i;
-
-		for (i = 0; i < nsyscall_vec[p]; ++i) {
-			if (!sysent_vec[p][i].sys_name
-			    || (sysent_vec[p][i].sys_flags & n) != n) {
-				continue;
-			}
-			add_number_to_set(i, &set[p]);
-		}
-	}
-
-	return true;
-}
-
-static bool
-qualify_syscall_name(const char *s, struct number_set *set)
-{
-	unsigned int p;
-	bool found = false;
-
-	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-		unsigned int i;
-
-		for (i = 0; i < nsyscall_vec[p]; ++i) {
-			if (!sysent_vec[p][i].sys_name
-			    || strcmp(s, sysent_vec[p][i].sys_name)) {
-				continue;
-			}
-			add_number_to_set(i, &set[p]);
-			found = true;
-		}
-	}
-
-	return found;
-}
-
-static bool
-qualify_syscall(const char *token, struct number_set *set)
-{
-	bool ignore_fail = false;
-
-	while (*token == '?') {
-		token++;
-		ignore_fail = true;
-	}
-	if (*token >= '0' && *token <= '9')
-		return qualify_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)
-	       || ignore_fail;
-}
-
-/*
- * Add syscall numbers to SETs for each supported personality
- * according to STR specification.
- */
-static void
-qualify_syscall_tokens(const char *const str, struct number_set *const set,
-		       const char *const name)
-{
-	/* Clear all sets. */
-	unsigned int p;
-	for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-		if (set[p].nslots)
-			memset(set[p].vec, 0,
-			       sizeof(*set[p].vec) * set[p].nslots);
-		set[p].not = false;
-	}
-
-	/*
-	 * Each leading ! character means inversion
-	 * of the remaining specification.
-	 */
-	const char *s = str;
-handle_inversion:
-	while (*s == '!') {
-		for (p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
-			set[p].not = !set[p].not;
-		}
-		++s;
-	}
-
-	if (strcmp(s, "none") == 0) {
-		/*
-		 * No syscall numbers are added to sets.
-		 * Subsequent is_number_in_set invocations
-		 * will return set[p]->not.
-		 */
-		return;
-	} else if (strcmp(s, "all") == 0) {
-		s = "!none";
-		goto handle_inversion;
-	}
-
-	/*
-	 * Split the string into comma separated tokens.
-	 * For each token, call qualify_syscall that will take care
-	 * if adding appropriate syscall numbers to sets.
-	 * The absence of tokens or a negative return code
-	 * from qualify_syscall is a fatal error.
-	 */
-	char *copy = xstrdup(s);
-	char *saveptr = NULL;
-	const char *token;
-	bool done = false;
-
-	for (token = strtok_r(copy, ",", &saveptr); token;
-	     token = strtok_r(NULL, ",", &saveptr)) {
-		done = qualify_syscall(token, set);
-		if (!done) {
-			error_msg_and_die("invalid %s '%s'", name, token);
-		}
-	}
-
-	free(copy);
-
-	if (!done) {
-		error_msg_and_die("invalid %s '%s'", name, str);
-	}
-}
-
-static int
-find_errno_by_name(const char *name)
-{
-	unsigned int i;
-
-	for (i = 1; i < nerrnos; ++i) {
-		if (errnoent[i] && (strcasecmp(name, errnoent[i]) == 0))
-			return i;
-	}
-
-	return -1;
-}
-
-static bool
-parse_inject_token(const char *const token, struct inject_opts *const fopts,
-		   const bool fault_tokens_only)
-{
-	const char *val;
-	int intval;
-
-	if ((val = STR_STRIP_PREFIX(token, "when=")) != token) {
-		/*
-		 *	== 1+1
-		 * F	== F+0
-		 * F+	== F+1
-		 * F+S
-		 */
-		char *end;
-		intval = string_to_uint_ex(val, &end, 0xffff, "+");
-		if (intval < 1)
-			return false;
-
-		fopts->first = intval;
-
-		if (*end) {
-			val = end + 1;
-			if (*val) {
-				/* F+S */
-				intval = string_to_uint_upto(val, 0xffff);
-				if (intval < 1)
-					return false;
-				fopts->step = intval;
-			} else {
-				/* F+ == F+1 */
-				fopts->step = 1;
-			}
-		} else {
-			/* F == F+0 */
-			fopts->step = 0;
-		}
-	} else if ((val = STR_STRIP_PREFIX(token, "error=")) != token) {
-		if (fopts->rval != INJECT_OPTS_RVAL_DEFAULT)
-			return false;
-		intval = string_to_uint_upto(val, MAX_ERRNO_VALUE);
-		if (intval < 0)
-			intval = find_errno_by_name(val);
-		if (intval < 1)
-			return false;
-		fopts->rval = -intval;
-	} else if (!fault_tokens_only
-		   && (val = STR_STRIP_PREFIX(token, "retval=")) != token) {
-		if (fopts->rval != INJECT_OPTS_RVAL_DEFAULT)
-			return false;
-		intval = string_to_uint(val);
-		if (intval < 0)
-			return false;
-		fopts->rval = intval;
-	} else if (!fault_tokens_only
-		   && (val = STR_STRIP_PREFIX(token, "signal=")) != token) {
-		intval = sigstr_to_uint(val);
-		if (intval < 1 || intval > NSIG_BYTES * 8)
-			return false;
-		fopts->signo = intval;
-	} else {
-		return false;
-	}
-
-	return true;
-}
-
-static char *
-parse_inject_expression(const char *const s, char **buf,
-			struct inject_opts *const fopts,
-			const bool fault_tokens_only)
-{
-	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;
-	}
-
-	if (name)
-		return name;
-
-parse_error:
-	free(*buf);
-	return *buf = NULL;
-}
-
-static void
-qualify_read(const char *const str)
-{
-	qualify_tokens(str, &read_set, string_to_uint, "descriptor");
-}
-
-static void
-qualify_write(const char *const str)
-{
-	qualify_tokens(str, &write_set, string_to_uint, "descriptor");
-}
-
-static void
-qualify_signals(const char *const str)
-{
-	qualify_tokens(str, &signal_set, sigstr_to_uint, "signal");
-}
-
-static void
-qualify_trace(const char *const str)
-{
-	qualify_syscall_tokens(str, trace_set, "system call");
-}
-
-static void
-qualify_abbrev(const char *const str)
-{
-	qualify_syscall_tokens(str, abbrev_set, "system call");
-}
-
-static void
-qualify_verbose(const char *const str)
-{
-	qualify_syscall_tokens(str, verbose_set, "system call");
-}
-
-static void
-qualify_raw(const char *const str)
-{
-	qualify_syscall_tokens(str, raw_set, "system call");
-}
-
-static void
-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[SUPPORTED_PERSONALITIES];
-	memset(tmp_set, 0, sizeof(tmp_set));
-	qualify_syscall_tokens(name, tmp_set, description);
-
-	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 (!tmp_set[p].nslots && !tmp_set[p].not) {
-			continue;
-		}
-
-		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(i, &tmp_set[p])) {
-				add_number_to_set(i, &inject_set[p]);
-				inject_vec[p][i] = opts;
-			}
-		}
-
-		free(tmp_set[p].vec);
-	}
-}
-
-static void
-qualify_fault(const char *const str)
-{
-	qualify_inject_common(str, true, "fault argument");
-}
-
-static void
-qualify_inject(const char *const str)
-{
-	qualify_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	},
-	{ "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	},
-};
-
-void
-qualify(const char *str)
-{
-	const struct qual_options *opt = qual_options;
-	unsigned int i;
-
-	for (i = 0; i < ARRAY_SIZE(qual_options); ++i) {
-		const char *name = qual_options[i].name;
-		const size_t len = strlen(name);
-		const char *val = str_strip_prefix_len(str, name, len);
-
-		if (val == str || *val != '=')
-			continue;
-		str = val + 1;
-		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);
-}
-- 
2.1.4





More information about the Strace-devel mailing list