[PATCH v2 0/5] libtracefs: Update filtering functions

[PATCH v2 0/5] libtracefs: Update filtering functions

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

Add tracefs_function_notrace() to set the functions not to trace.
Create a per instance pthread mutex lock.

Changes since v1:

 - Close the file descriptors on freeing of the instance
 - Close the file descriptors on exec.


Steven Rostedt (VMware) (5):
  libtracefs: Close filter file descriptor on freeing of instance
  libtracefs: Close the filter file descriptor on exec()
  libtracefs: Move most functionality into helper function for
    tracefs_function_filter()
  libtracefs: Add tracefs_function_notrace() API
  libtracefs: Add a pthread_mutex per instance

 Documentation/libtracefs-function-filter.txt |  19 ++-
 include/tracefs-local.h                      |  12 +-
 include/tracefs.h                            |   3 +
 src/tracefs-instance.c                       |  13 ++
 src/tracefs-tools.c                          | 152 ++++++++++++-------
 5 files changed, 138 insertions(+), 61 deletions(-)

-- 
2.29.2

[PATCH v2 1/5] libtracefs: Close filter file descriptor on freeing of instance

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

If the instance ftrace_filter_fd is open on freeing of the instance, close
it.

Link: https://lore.kernel.org/linux-trace-devel/20210408085340.5e84064f@gandalf.local.home/

Suggested-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
---
 src/tracefs-instance.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tracefs-instance.c b/src/tracefs-instance.c
index bf2fabf..e222191 100644
--- a/src/tracefs-instance.c
+++ b/src/tracefs-instance.c
@@ -66,6 +66,10 @@ void tracefs_instance_free(struct tracefs_instance *instance)
 {
 	if (!instance)
 		return;
+
+	if (instance->ftrace_filter_fd >= 0)
+		close(instance->ftrace_filter_fd);
+
 	free(instance->trace_dir);
 	free(instance->name);
 	free(instance);
-- 
2.29.2

[PATCH v2 2/5] libtracefs: Close the filter file descriptor on exec()

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

There's no reason to keep the function filter file descriptor open if the
application does an exec(). That can end up being a security issue. Best
to set O_CLOEXEC flag when opening such that if the application leaves the
file open and does an exec, it will be closed and the exec code does not
have write permission into that file.

If someone wants to have the file descriptor opened, then they need to
open code the access to the file themselves, and if they want to use the
API for such a use case, then they should submit a bugzilla with an
enhancement request.

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
---
 src/tracefs-tools.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tracefs-tools.c b/src/tracefs-tools.c
index cb07b6f..92e3f72 100644
--- a/src/tracefs-tools.c
+++ b/src/tracefs-tools.c
@@ -853,7 +853,7 @@ int tracefs_function_filter(struct tracefs_instance *instance, const char *filte
 	open_flags = reset ? O_TRUNC : O_APPEND;
 
 	if (*fd < 0)
-		*fd = open(ftrace_filter_path, O_WRONLY | open_flags);
+		*fd = open(ftrace_filter_path, O_WRONLY | O_CLOEXEC | open_flags);
 	tracefs_put_tracing_file(ftrace_filter_path);
 	if (*fd < 0)
 		goto out_free;
-- 
2.29.2

[PATCH v2 3/5] libtracefs: Move most functionality into helper function for tracefs_function_filter()

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

In order to share the code of tracefs_function_filter() for
tracefs_function_notrace(), move all its functionality out of
tracefs_function_filter() and into a new helper function called
update_filter(). Then pass in the filter file and the pointer to the file
descriptor to the set_ftrace_filter, such that tracefs_function_notrace()
could do the same with set_ftrace_notrace file.

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
---
 src/tracefs-tools.c | 111 ++++++++++++++++++++++++--------------------
 1 file changed, 61 insertions(+), 50 deletions(-)

diff --git a/src/tracefs-tools.c b/src/tracefs-tools.c
index 92e3f72..9bd9a72 100644
--- a/src/tracefs-tools.c
+++ b/src/tracefs-tools.c
@@ -744,54 +744,17 @@ static int write_func_list(int fd, struct func_list *list)
 	return 0;
 }
 
-/**
- * tracefs_function_filter - filter the functions that are traced
- * @instance: ftrace instance, can be NULL for top tracing instance.
- * @filter: The filter to filter what functions are to be traced
- * @module: Module to be traced or NULL if all functions are to be examined.
- * @flags: flags on modifying the filter file
- *
- * @filter may be a full function name, a glob, or a regex. It will be
- * considered a regex, if there's any characters that are not normally in
- * function names or "*" or "?" for a glob.
- *
- * @flags:
- *   TRACEFS_FL_RESET - will clear the functions in the filter file
- *          before applying the @filter. This will error with -1
- *          and errno of EBUSY if this flag is set and a previous
- *          call had the same instance and TRACEFS_FL_CONTINUE set.
- *   TRACEFS_FL_CONTINUE - will keep the filter file open on return.
- *          The filter is updated on closing of the filter file.
- *          With this flag set, the file is not closed, and more filters
- *          may be added before they take effect. The last call of this
- *          function must be called without this flag for the filter
- *          to take effect.
- *   TRACEFS_FL_FUTURE - only applicable if "module" is set. If no match
- *          is made, and the module is not yet loaded, it will still attempt
- *          to write the filter plus the module; "<filter>:mod:<module>"
- *          to the filter file. Starting with Linux kernels 4.13, it is possible
- *          to load the filter file with module functions for a module that
- *          is not yet loaded, and when the module is loaded, it will then
- *          activate the module.
- *
- * Returns 0 on success, 1 if there was an error but the filtering has not
- *  yet started, -1 if there was an error but the filtering has started.
- *  If -1 is returned and TRACEFS_FL_CONTINUE was set, then this function
- *  needs to be called again without the TRACEFS_FL_CONTINUE flag to commit
- *  the changes and close the filter file.
- */
-int tracefs_function_filter(struct tracefs_instance *instance, const char *filter,
-			    const char *module, unsigned int flags)
+static int update_filter(const char *filter_path, int *fd,
+			 struct tracefs_instance *instance, const char *filter,
+			 const char *module, unsigned int flags)
 {
 	struct func_filter func_filter;
 	struct func_list *func_list = NULL;
-	char *ftrace_filter_path;
 	bool reset = flags & TRACEFS_FL_RESET;
 	bool cont = flags & TRACEFS_FL_CONTINUE;
 	bool future = flags & TRACEFS_FL_FUTURE;
 	int open_flags;
 	int ret = 1;
-	int *fd;
 
 	/* future flag is only applicable to modules */
 	if (future && !module) {
@@ -800,10 +763,6 @@ int tracefs_function_filter(struct tracefs_instance *instance, const char *filte
 	}
 
 	pthread_mutex_lock(&filter_lock);
-	if (instance)
-		fd = &instance->ftrace_filter_fd;
-	else
-		fd = &ftrace_filter_fd;
 
 	/* RESET is only allowed if the file is not opened yet */
 	if (reset && *fd >= 0) {
@@ -846,20 +805,15 @@ int tracefs_function_filter(struct tracefs_instance *instance, const char *filte
 
  open_file:
 	ret = 1;
-	ftrace_filter_path = tracefs_instance_get_file(instance, TRACE_FILTER);
-	if (!ftrace_filter_path)
-		goto out_free;
 
 	open_flags = reset ? O_TRUNC : O_APPEND;
 
 	if (*fd < 0)
-		*fd = open(ftrace_filter_path, O_WRONLY | O_CLOEXEC | open_flags);
-	tracefs_put_tracing_file(ftrace_filter_path);
+		*fd = open(filter_path, O_WRONLY | O_CLOEXEC | open_flags);
 	if (*fd < 0)
 		goto out_free;
 
 	errno = 0;
-
 	ret = 0;
 
 	if (filter) {
@@ -887,3 +841,60 @@ int tracefs_function_filter(struct tracefs_instance *instance, const char *filte
 
 	return ret;
 }
+
+/**
+ * tracefs_function_filter - filter the functions that are traced
+ * @instance: ftrace instance, can be NULL for top tracing instance.
+ * @filter: The filter to filter what functions are to be traced
+ * @module: Module to be traced or NULL if all functions are to be examined.
+ * @flags: flags on modifying the filter file
+ *
+ * @filter may be a full function name, a glob, or a regex. It will be
+ * considered a regex, if there's any characters that are not normally in
+ * function names or "*" or "?" for a glob.
+ *
+ * @flags:
+ *   TRACEFS_FL_RESET - will clear the functions in the filter file
+ *          before applying the @filter. This will error with -1
+ *          and errno of EBUSY if this flag is set and a previous
+ *          call had the same instance and TRACEFS_FL_CONTINUE set.
+ *   TRACEFS_FL_CONTINUE - will keep the filter file open on return.
+ *          The filter is updated on closing of the filter file.
+ *          With this flag set, the file is not closed, and more filters
+ *          may be added before they take effect. The last call of this
+ *          function must be called without this flag for the filter
+ *          to take effect.
+ *   TRACEFS_FL_FUTURE - only applicable if "module" is set. If no match
+ *          is made, and the module is not yet loaded, it will still attempt
+ *          to write the filter plus the module; "<filter>:mod:<module>"
+ *          to the filter file. Starting with Linux kernels 4.13, it is possible
+ *          to load the filter file with module functions for a module that
+ *          is not yet loaded, and when the module is loaded, it will then
+ *          activate the module.
+ *
+ * Returns 0 on success, 1 if there was an error but the filtering has not
+ *  yet started, -1 if there was an error but the filtering has started.
+ *  If -1 is returned and TRACEFS_FL_CONTINUE was set, then this function
+ *  needs to be called again without the TRACEFS_FL_CONTINUE flag to commit
+ *  the changes and close the filter file.
+ */
+int tracefs_function_filter(struct tracefs_instance *instance, const char *filter,
+			    const char *module, unsigned int flags)
+{
+	char *filter_path;
+	int *fd;
+	int ret;
+
+	filter_path = tracefs_instance_get_file(instance, TRACE_FILTER);
+	if (!filter_path)
+		return -1;
+
+	if (instance)
+		fd = &instance->ftrace_filter_fd;
+	else
+		fd = &ftrace_filter_fd;
+
+	ret = update_filter(filter_path, fd, instance, filter, module, flags);
+	tracefs_put_tracing_file(filter_path);
+	return ret;
+}
-- 
2.29.2

[PATCH v2 4/5] libtracefs: Add tracefs_function_notrace() API

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

Add the API of tracefs_function_notrace() that is identical to how
tracefs_function_filter() works, but will work with the set_ftrace_notrace
filter file.

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
---
Changes since v1:
 - Close the descriptor when the instance is freed.

 Documentation/libtracefs-function-filter.txt | 19 ++++++++---
 include/tracefs-local.h                      |  1 +
 include/tracefs.h                            |  3 ++
 src/tracefs-instance.c                       |  4 +++
 src/tracefs-tools.c                          | 33 ++++++++++++++++++++
 5 files changed, 56 insertions(+), 4 deletions(-)

diff --git a/Documentation/libtracefs-function-filter.txt b/Documentation/libtracefs-function-filter.txt
index ccf20e9..746be37 100644
--- a/Documentation/libtracefs-function-filter.txt
+++ b/Documentation/libtracefs-function-filter.txt
@@ -4,6 +4,7 @@ libtracefs(3)
 NAME
 ----
 tracefs_function_filter - Function to limit kernel functions that are traced
+tracefs_function_notrace - Function to filter kernel functions that not to be traced
 
 SYNOPSIS
 --------
@@ -12,15 +13,18 @@ SYNOPSIS
 *#include <tracefs.h>*
 
 int *tracefs_function_filter*(struct tracefs_instance pass:[*]_instance_, const char pass:[*]_filter_, const char pass:[*]_module_, int _flags_);
+int *tracefs_function_notrace*(struct tracefs_instance pass:[*]_instance_, const char pass:[*]_filter_, const char pass:[*]_module_, int _flags_);
 --
 
 DESCRIPTION
 -----------
-This function can be used to limit the Linux kernel functions that would be
-traced by the function and function-graph tracers
+*tracefs_function_filter* and *tracefs_function_notrace* can be used to limit the
+Linux kernel functions that would be traced by the function and function-graph tracers.
+The *tracefs_function_filter* defines a list of functions that can be traced.
+The *tracefs_function_notrace* defines a list of functions that will not be traced.
+If a function is in both lists, it will not be traced.
 
-It will take an
-_instance_ , that can be NULL for the top level tracing,
+They take an _instance_ , that can be NULL for the top level tracing,
 _filter_, a string that represents a filter that should
 be applied to define what functions are to be traced,
 _module_, to limit the filtering on a specific module (or NULL to filter on all functions),
@@ -125,6 +129,13 @@ int main(int argc, char *argv[])
 		/* Error creating new trace instance */
 	}
 
+	/* Do not trace any function with the word "lock" in it */
+	ret = tracefs_function_notrace(inst, "*lock*", NULL, TRACEFS_FL_RESET);
+	if (ret) {
+		printf("Failed to set the notrace filter\n");
+		goto out;
+	}
+
 	/* First reset the filter */
 	ret = tracefs_function_filter(inst, NULL, NULL,
 				      TRACEFS_FL_RESET | TRACEFS_FL_CONTINUE);
diff --git a/include/tracefs-local.h b/include/tracefs-local.h
index 73ec113..060de7e 100644
--- a/include/tracefs-local.h
+++ b/include/tracefs-local.h
@@ -19,6 +19,7 @@ struct tracefs_instance {
 	char	*name;
 	int	flags;
 	int	ftrace_filter_fd;
+	int	ftrace_notrace_fd;
 };
 
 /* Can be overridden */
diff --git a/include/tracefs.h b/include/tracefs.h
index befcc48..70b7ebe 100644
--- a/include/tracefs.h
+++ b/include/tracefs.h
@@ -160,4 +160,7 @@ enum {
 
 int tracefs_function_filter(struct tracefs_instance *instance, const char *filter,
 			    const char *module, unsigned int flags);
+int tracefs_function_notrace(struct tracefs_instance *instance, const char *filter,
+			     const char *module, unsigned int flags);
+
 #endif /* _TRACE_FS_H */
diff --git a/src/tracefs-instance.c b/src/tracefs-instance.c
index e222191..6ccf7d8 100644
--- a/src/tracefs-instance.c
+++ b/src/tracefs-instance.c
@@ -44,6 +44,7 @@ static struct tracefs_instance *instance_alloc(const char *trace_dir, const char
 	}
 
 	instance->ftrace_filter_fd = -1;
+	instance->ftrace_notrace_fd = -1;
 
 	return instance;
 
@@ -70,6 +71,9 @@ void tracefs_instance_free(struct tracefs_instance *instance)
 	if (instance->ftrace_filter_fd >= 0)
 		close(instance->ftrace_filter_fd);
 
+	if (instance->ftrace_notrace_fd >= 0)
+		close(instance->ftrace_notrace_fd);
+
 	free(instance->trace_dir);
 	free(instance->name);
 	free(instance);
diff --git a/src/tracefs-tools.c b/src/tracefs-tools.c
index 9bd9a72..0f733b4 100644
--- a/src/tracefs-tools.c
+++ b/src/tracefs-tools.c
@@ -21,10 +21,12 @@
 
 #define TRACE_CTRL		"tracing_on"
 #define TRACE_FILTER		"set_ftrace_filter"
+#define TRACE_NOTRACE		"set_ftrace_notrace"
 #define TRACE_FILTER_LIST	"available_filter_functions"
 
 /* File descriptor for Top level set_ftrace_filter  */
 static int ftrace_filter_fd = -1;
+static int ftrace_notrace_fd = -1;
 static pthread_mutex_t filter_lock = PTHREAD_MUTEX_INITIALIZER;
 
 static const char * const options_map[] = {
@@ -898,3 +900,34 @@ int tracefs_function_filter(struct tracefs_instance *instance, const char *filte
 	tracefs_put_tracing_file(filter_path);
 	return ret;
 }
+
+/**
+ * tracefs_function_notrace - filter the functions that are not to be traced
+ * @instance: ftrace instance, can be NULL for top tracing instance.
+ * @filter: The filter to filter what functions are not to be traced
+ * @module: Module to be traced or NULL if all functions are to be examined.
+ * @flags: flags on modifying the filter file
+ *
+ * See tracefs_function_filter, as this has the same functionality but
+ * for adding to the "notrace" filter.
+ */
+int tracefs_function_notrace(struct tracefs_instance *instance, const char *filter,
+			     const char *module, unsigned int flags)
+{
+	char *filter_path;
+	int *fd;
+	int ret;
+
+	filter_path = tracefs_instance_get_file(instance, TRACE_NOTRACE);
+	if (!filter_path)
+		return -1;
+
+	if (instance)
+		fd = &instance->ftrace_notrace_fd;
+	else
+		fd = &ftrace_notrace_fd;
+
+	ret = update_filter(filter_path, fd, instance, filter, module, flags);
+	tracefs_put_tracing_file(filter_path);
+	return ret;
+}
-- 
2.29.2

[PATCH v2 5/5] libtracefs: Add a pthread_mutex per instance

[Steven Rostedt]

From: "Steven Rostedt (VMware)" <rostedt@goodmis.org>

Add a pthread_mutex per instance such that modifications being done on
specific instances do not interfere with each other. This also includes a
new "toplevel_lock" that is to be used when modifying the toplevel
instance.

Convert the filter_mutex over to the toplevel/instance locking.

Signed-off-by: Steven Rostedt (VMware) <rostedt@goodmis.org>
---
 include/tracefs-local.h | 13 ++++++++-----
 src/tracefs-instance.c  |  5 +++++
 src/tracefs-tools.c     |  8 +++++---
 3 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/include/tracefs-local.h b/include/tracefs-local.h
index 060de7e..6865611 100644
--- a/include/tracefs-local.h
+++ b/include/tracefs-local.h
@@ -15,13 +15,16 @@
 	do { if (!(1/!(cond))) { } } while (0)
 
 struct tracefs_instance {
-	char	*trace_dir;
-	char	*name;
-	int	flags;
-	int	ftrace_filter_fd;
-	int	ftrace_notrace_fd;
+	char			*trace_dir;
+	char			*name;
+	pthread_mutex_t		lock;
+	int			flags;
+	int			ftrace_filter_fd;
+	int			ftrace_notrace_fd;
 };
 
+extern pthread_mutex_t toplevel_lock;
+
 /* Can be overridden */
 void warning(const char *fmt, ...);
 
diff --git a/src/tracefs-instance.c b/src/tracefs-instance.c
index 6ccf7d8..41ad1f5 100644
--- a/src/tracefs-instance.c
+++ b/src/tracefs-instance.c
@@ -15,6 +15,7 @@
 #include <fcntl.h>
 #include <dirent.h>
 #include <limits.h>
+#include <pthread.h>
 #include "tracefs.h"
 #include "tracefs-local.h"
 
@@ -43,6 +44,9 @@ static struct tracefs_instance *instance_alloc(const char *trace_dir, const char
 			goto error;
 	}
 
+	if (pthread_mutex_init(&instance->lock, NULL) < 0)
+		goto error;
+
 	instance->ftrace_filter_fd = -1;
 	instance->ftrace_notrace_fd = -1;
 
@@ -76,6 +80,7 @@ void tracefs_instance_free(struct tracefs_instance *instance)
 
 	free(instance->trace_dir);
 	free(instance->name);
+	pthread_mutex_destroy(&instance->lock);
 	free(instance);
 }
 
diff --git a/src/tracefs-tools.c b/src/tracefs-tools.c
index 0f733b4..037875f 100644
--- a/src/tracefs-tools.c
+++ b/src/tracefs-tools.c
@@ -19,6 +19,8 @@
 #include "tracefs.h"
 #include "tracefs-local.h"
 
+__hidden pthread_mutex_t toplevel_lock = PTHREAD_MUTEX_INITIALIZER;
+
 #define TRACE_CTRL		"tracing_on"
 #define TRACE_FILTER		"set_ftrace_filter"
 #define TRACE_NOTRACE		"set_ftrace_notrace"
@@ -27,7 +29,6 @@
 /* File descriptor for Top level set_ftrace_filter  */
 static int ftrace_filter_fd = -1;
 static int ftrace_notrace_fd = -1;
-static pthread_mutex_t filter_lock = PTHREAD_MUTEX_INITIALIZER;
 
 static const char * const options_map[] = {
 	"unknown",
@@ -755,6 +756,7 @@ static int update_filter(const char *filter_path, int *fd,
 	bool reset = flags & TRACEFS_FL_RESET;
 	bool cont = flags & TRACEFS_FL_CONTINUE;
 	bool future = flags & TRACEFS_FL_FUTURE;
+	pthread_mutex_t *lock = instance ? &instance->lock : &toplevel_lock;
 	int open_flags;
 	int ret = 1;
 
@@ -764,7 +766,7 @@ static int update_filter(const char *filter_path, int *fd,
 		return 1;
 	}
 
-	pthread_mutex_lock(&filter_lock);
+	pthread_mutex_lock(lock);
 
 	/* RESET is only allowed if the file is not opened yet */
 	if (reset && *fd >= 0) {
@@ -839,7 +841,7 @@ static int update_filter(const char *filter_path, int *fd,
  out_free:
 	free_func_list(func_list);
  out:
-	pthread_mutex_unlock(&filter_lock);
+	pthread_mutex_unlock(lock);
 
 	return ret;
 }
-- 
2.29.2