* [PATCH v2 1/3] libtracefs: New API to reset ftrace instance
2023-04-26 4:11 [PATCH v2 0/3] libtracefs: Introduce new API to reset ftrace instance Tzvetomir Stoyanov (VMware)
@ 2023-04-26 4:11 ` Tzvetomir Stoyanov (VMware)
2023-04-26 4:11 ` [PATCH v2 2/3] libtracefs: Documentation for tracefs_instance_reset() Tzvetomir Stoyanov (VMware)
2023-04-26 4:11 ` [PATCH v2 3/3] libtracefs: Unit test " Tzvetomir Stoyanov (VMware)
2 siblings, 0 replies; 6+ messages in thread
From: Tzvetomir Stoyanov (VMware) @ 2023-04-26 4:11 UTC (permalink / raw)
To: rostedt; +Cc: linux-trace-devel
Resetting a ftrace instance to its default state is not a trivial task.
A lot of trace files have to be modified, with different syntaxes and
in strict order. Although there is such functionality in "trace-cmd
reset" command, it will be good to have it in the tracefs library as
well.
A new API tracefs_instance_reset() is introduced, which resets given
ftrace instance to its default state. The logic and most of the helper
functions from "trace-cmd reset" command are copied in the tracefs
library.
Signed-off-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
---
include/tracefs-local.h | 1 +
include/tracefs.h | 1 +
src/tracefs-instance.c | 207 ++++++++++++++++++++++++++++++++++++++++
src/tracefs-utils.c | 20 ++++
4 files changed, 229 insertions(+)
diff --git a/include/tracefs-local.h b/include/tracefs-local.h
index 2007d26..da99a30 100644
--- a/include/tracefs-local.h
+++ b/include/tracefs-local.h
@@ -64,6 +64,7 @@ int trace_get_instance(struct tracefs_instance *instance);
/* Can be overridden */
void tracefs_warning(const char *fmt, ...);
+char *strstrip(char *str);
int str_read_file(const char *file, char **buffer, bool warn);
char *trace_append_file(const char *dir, const char *name);
char *trace_find_tracing_dir(bool debugfs);
diff --git a/include/tracefs.h b/include/tracefs.h
index 3547b5a..5e9d84b 100644
--- a/include/tracefs.h
+++ b/include/tracefs.h
@@ -23,6 +23,7 @@ int tracefs_tracing_dir_is_mounted(bool mount, const char **path);
struct tracefs_instance;
void tracefs_instance_free(struct tracefs_instance *instance);
+void tracefs_instance_reset(struct tracefs_instance *instance);
struct tracefs_instance *tracefs_instance_create(const char *name);
struct tracefs_instance *tracefs_instance_alloc(const char *tracing_dir,
const char *name);
diff --git a/src/tracefs-instance.c b/src/tracefs-instance.c
index 57f5c7f..b3ed983 100644
--- a/src/tracefs-instance.c
+++ b/src/tracefs-instance.c
@@ -1239,3 +1239,210 @@ char *tracefs_instance_get_affinity(struct tracefs_instance *instance)
return set;
}
+
+static int clear_trigger(const char *file)
+{
+ char trigger[BUFSIZ];
+ char *save = NULL;
+ char *line;
+ char *buf;
+ int size;
+ int len;
+ int ret;
+
+ size = str_read_file(file, &buf, true);
+ if (size < 1)
+ return 0;
+
+ trigger[0] = '!';
+
+ for (line = strtok_r(buf, "\n", &save); line; line = strtok_r(NULL, "\n", &save)) {
+ if (line[0] == '#')
+ continue;
+ len = strlen(line);
+ if (len > BUFSIZ - 2)
+ len = BUFSIZ - 2;
+ strncpy(trigger + 1, line, len);
+ trigger[len + 1] = '\0';
+ /* We don't want any filters or extra on the line */
+ strtok(trigger, " ");
+ write_file(file, trigger, O_WRONLY);
+ }
+
+ free(buf);
+
+ /*
+ * Some triggers have an order in removing them.
+ * They will not be removed if done in the wrong order.
+ */
+ size = str_read_file(file, &buf, true);
+ if (size < 1)
+ return 0;
+
+ ret = 0;
+ for (line = strtok(buf, "\n"); line; line = strtok(NULL, "\n")) {
+ if (line[0] == '#')
+ continue;
+ ret = 1;
+ break;
+ }
+ free(buf);
+ return ret;
+}
+
+static void disable_func_stack_trace_instance(struct tracefs_instance *instance)
+{
+ char *content;
+ char *cond;
+ int size;
+
+ content = tracefs_instance_file_read(instance, "current_tracer", &size);
+ if (!content)
+ return;
+ cond = strstrip(content);
+ if (memcmp(cond, "function", size - (cond - content)) != 0)
+ goto out;
+
+ tracefs_option_disable(instance, TRACEFS_OPTION_FUNC_STACKTRACE);
+ out:
+ free(content);
+}
+
+static void reset_cpu_mask(struct tracefs_instance *instance)
+{
+ int cpus = sysconf(_SC_NPROCESSORS_CONF);
+ int fullwords = (cpus - 1) / 32;
+ int bits = (cpus - 1) % 32 + 1;
+ int len = (fullwords + 1) * 9;
+ char buf[len + 1];
+
+ buf[0] = '\0';
+ sprintf(buf, "%x", (unsigned int)((1ULL << bits) - 1));
+ while (fullwords-- > 0)
+ strcat(buf, ",ffffffff");
+
+ tracefs_instance_file_write(instance, "tracing_cpumask", buf);
+}
+
+static void clear_func_filter(struct tracefs_instance *instance, const char *file)
+{
+ char filter[BUFSIZ];
+ char *line;
+ char *buf;
+ char *p;
+ int len;
+
+ buf = tracefs_instance_file_read(instance, file, NULL);
+ if (!buf)
+ return;
+
+ /* Now remove filters */
+ filter[0] = '!';
+
+ /*
+ * To delete a filter, we need to write a '!filter'
+ * to the file for each filter.
+ */
+ for (line = strtok(buf, "\n"); line; line = strtok(NULL, "\n")) {
+ if (line[0] == '#')
+ continue;
+ len = strlen(line);
+ if (len > BUFSIZ - 2)
+ len = BUFSIZ - 2;
+
+ strncpy(filter + 1, line, len);
+ filter[len + 1] = '\0';
+ /*
+ * To remove "unlimited" filters, we must remove
+ * the ":unlimited" from what we write.
+ */
+ p = strstr(filter, ":unlimited");
+ if (p) {
+ *p = '\0';
+ len = p - filter;
+ }
+ /*
+ * The write to this file expects white space
+ * at the end :-p
+ */
+ filter[len] = '\n';
+ filter[len+1] = '\0';
+ tracefs_instance_file_append(instance, file, filter);
+ }
+}
+
+static void clear_func_filters(struct tracefs_instance *instance)
+{
+ int i;
+ const char * const files[] = { "set_ftrace_filter",
+ "set_ftrace_notrace",
+ "set_graph_function",
+ "set_graph_notrace",
+ "stack_trace_filter",
+ NULL };
+
+ for (i = 0; files[i]; i++)
+ clear_func_filter(instance, files[i]);
+}
+
+/**
+ * tracefs_instance_reset - Reset a ftrace instance to its default state
+ * @instance - a ftrace instance to be reseted
+ *
+ * The main logic and the helper functions are copied from
+ * trace-cmd/tracecmd/trace-record.c, trace_reset()
+ */
+void tracefs_instance_reset(struct tracefs_instance *instance)
+{
+ int has_trigger = -1;
+ char **systems;
+ struct stat st;
+ char **events;
+ char *file;
+ int i, j;
+
+ tracefs_trace_off(instance);
+ disable_func_stack_trace_instance(instance);
+ tracefs_tracer_clear(instance);
+ tracefs_instance_file_write(instance, "events/enable", "0");
+ tracefs_instance_file_write(instance, "set_ftrace_pid", "");
+ tracefs_instance_file_clear(instance, "trace");
+
+ systems = tracefs_event_systems(NULL);
+ if (systems) {
+ for (i = 0; systems[i]; i++) {
+ events = tracefs_system_events(NULL, systems[i]);
+ if (!events)
+ continue;
+ for (j = 0; events[j]; j++) {
+ file = tracefs_event_get_file(instance, systems[i],
+ events[j], "filter");
+ write_file(file, "0", O_WRONLY | O_TRUNC);
+ tracefs_put_tracing_file(file);
+
+ file = tracefs_event_get_file(instance, systems[i],
+ events[j], "trigger");
+ if (has_trigger < 0) {
+ /* Check if the kernel is configured with triggers */
+ if (stat(file, &st) < 0)
+ has_trigger = 0;
+ else
+ has_trigger = 1;
+ }
+ if (has_trigger)
+ clear_trigger(file);
+ tracefs_put_tracing_file(file);
+ }
+ tracefs_list_free(events);
+ }
+ tracefs_list_free(systems);
+ }
+
+ tracefs_instance_file_write(instance, "error_log", " ");
+ tracefs_instance_file_write(instance, "trace_clock", "local");
+ tracefs_instance_file_write(instance, "set_event_pid", "");
+ reset_cpu_mask(instance);
+ clear_func_filters(instance);
+ tracefs_instance_file_write(instance, "tracing_max_latency", "0");
+ tracefs_trace_on(instance);
+}
diff --git a/src/tracefs-utils.c b/src/tracefs-utils.c
index 9acf2ad..ef90677 100644
--- a/src/tracefs-utils.c
+++ b/src/tracefs-utils.c
@@ -319,6 +319,26 @@ void tracefs_put_tracing_file(char *name)
free(name);
}
+/* The function is copied from trace-cmd */
+__hidden char *strstrip(char *str)
+{
+ char *s;
+
+ if (!str)
+ return NULL;
+
+ s = str + strlen(str) - 1;
+ while (s >= str && isspace(*s))
+ s--;
+ s++;
+ *s = '\0';
+
+ for (s = str; *s && isspace(*s); s++)
+ ;
+
+ return s;
+}
+
__hidden int str_read_file(const char *file, char **buffer, bool warn)
{
char stbuf[BUFSIZ];
--
2.39.2
^ permalink raw reply related [flat|nested] 6+ messages in thread* [PATCH v2 3/3] libtracefs: Unit test for tracefs_instance_reset()
2023-04-26 4:11 [PATCH v2 0/3] libtracefs: Introduce new API to reset ftrace instance Tzvetomir Stoyanov (VMware)
2023-04-26 4:11 ` [PATCH v2 1/3] libtracefs: New " Tzvetomir Stoyanov (VMware)
2023-04-26 4:11 ` [PATCH v2 2/3] libtracefs: Documentation for tracefs_instance_reset() Tzvetomir Stoyanov (VMware)
@ 2023-04-26 4:11 ` Tzvetomir Stoyanov (VMware)
2023-05-29 12:05 ` Steven Rostedt
2 siblings, 1 reply; 6+ messages in thread
From: Tzvetomir Stoyanov (VMware) @ 2023-04-26 4:11 UTC (permalink / raw)
To: rostedt; +Cc: linux-trace-devel
The logic of the tracefs_instance_reset() is complex and should be
covered by the unit tests of the tracefs library.
Signed-off-by: Tzvetomir Stoyanov (VMware) <tz.stoyanov@gmail.com>
---
utest/tracefs-utest.c | 183 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 183 insertions(+)
diff --git a/utest/tracefs-utest.c b/utest/tracefs-utest.c
index e0e3c07..47f65cb 100644
--- a/utest/tracefs-utest.c
+++ b/utest/tracefs-utest.c
@@ -1618,6 +1618,187 @@ static void test_instance_file(void)
free(inst_dir);
}
+static bool test_check_file_content(struct tracefs_instance *instance, char *file,
+ char *content, bool full_match, bool ignore_comments)
+{
+ char *save = NULL;
+ char *buf, *line;
+ bool ret = false;
+ int len;
+
+ if (!tracefs_file_exists(instance, file))
+ return false;
+
+ buf = tracefs_instance_file_read(instance, file, NULL);
+ if (strlen(content) == 0) {
+ /* check for empty file */
+ if (!buf)
+ return true;
+ if (!ignore_comments) {
+ if (strlen(buf) > 0)
+ goto out;
+ } else {
+ line = strtok_r(buf, "\n", &save);
+ while (line) {
+ if (line[0] != '#')
+ goto out;
+ line = strtok_r(NULL, "\n", &save);
+ }
+ }
+ } else {
+ if (!buf || strlen(buf) < 1)
+ return false;
+ if (full_match) {
+ /* strip the newline */
+ len = strlen(buf) - 1;
+ while (buf[len] == '\n' || buf[len] == '\r') {
+ buf[len] = '\0';
+ len = strlen(buf) - 1;
+ if (len < 0)
+ goto out;
+ }
+ if (strcmp(buf, content))
+ goto out;
+ } else {
+ if (!strstr(buf, content))
+ goto out;
+ }
+ }
+
+ ret = true;
+out:
+ free(buf);
+ return ret;
+}
+
+static bool test_check_event_file_content(struct tracefs_instance *instance,
+ char *system, char *event, char *file,
+ char *content, bool full_match, bool ignore_comments)
+{
+ char *efile;
+ int ret;
+
+ ret = asprintf(&efile, "events/%s/%s/%s", system, event, file);
+ if (ret <= 0)
+ return false;
+ ret = test_check_file_content(instance, efile, content, full_match, ignore_comments);
+ free(efile);
+ return ret;
+}
+
+static bool check_cpu_mask(struct tracefs_instance *instance)
+{
+ int cpus = sysconf(_SC_NPROCESSORS_CONF);
+ int fullwords = (cpus - 1) / 32;
+ int bits = (cpus - 1) % 32 + 1;
+ int len = (fullwords + 1) * 9;
+ char buf[len + 1];
+
+ buf[0] = '\0';
+ sprintf(buf, "%x", (unsigned int)((1ULL << bits) - 1));
+ while (fullwords-- > 0)
+ strcat(buf, ",ffffffff");
+
+ return test_check_file_content(instance, "tracing_cpumask", buf, true, false);
+}
+
+static bool test_instance_check_default_state(struct tracefs_instance *instance)
+{
+ char **systems;
+ char **events;
+ int i, j;
+ int ok;
+
+ if (tracefs_trace_is_on(instance) != 1)
+ return false;
+ if (!test_check_file_content(instance, "current_tracer", "nop", true, false))
+ return false;
+ if (!test_check_file_content(instance, "events/enable", "0", true, false))
+ return false;
+ if (!test_check_file_content(instance, "set_ftrace_pid", "no pid", true, false))
+ return false;
+ if (!test_check_file_content(instance, "trace", "", true, true))
+ return false;
+ if (!test_check_file_content(instance, "error_log", "", true, false))
+ return false;
+ if (!test_check_file_content(instance, "trace_clock", "[local]", false, false))
+ return false;
+ if (!test_check_file_content(instance, "set_event_pid", "", true, false))
+ return false;
+ if (!test_check_file_content(instance, "tracing_max_latency", "0", true, false))
+ return false;
+ if (!test_check_file_content(instance, "set_ftrace_filter", "", true, true))
+ return false;
+ if (!test_check_file_content(instance, "set_ftrace_notrace", "", true, true))
+ return false;
+ if (!check_cpu_mask(instance))
+ return false;
+
+ ok = 1;
+ systems = tracefs_event_systems(NULL);
+ if (systems) {
+ for (i = 0; systems[i]; i++) {
+ events = tracefs_system_events(NULL, systems[i]);
+ if (!events)
+ continue;
+ for (j = 0; events[j]; j++) {
+ if (!test_check_event_file_content(instance, systems[i], events[j],
+ "enable", "0", true, false))
+ break;
+ if (!test_check_event_file_content(instance, systems[i], events[j],
+ "filter", "none", true, false))
+ break;
+ if (!test_check_event_file_content(instance, systems[i], events[j],
+ "trigger", "", true, true))
+ break;
+ }
+ if (events[j])
+ ok = 0;
+ tracefs_list_free(events);
+ if (!ok)
+ return false;
+ }
+ tracefs_list_free(systems);
+ }
+
+ return true;
+}
+
+static void test_instance_reset(void)
+{
+ struct tracefs_instance *instance = NULL;
+ const char *name = get_rand_str();
+
+ CU_TEST(tracefs_instance_exists(name) == false);
+ instance = tracefs_instance_create(name);
+ CU_TEST(instance != NULL);
+
+ CU_TEST(test_instance_check_default_state(instance) == true);
+
+ CU_TEST(tracefs_tracer_set(instance, TRACEFS_TRACER_HWLAT) == 0);
+ CU_TEST(tracefs_event_enable(instance, "bridge", "fdb_delete") == 0);
+ CU_TEST(tracefs_instance_file_write(instance, "set_ftrace_pid", "5") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "trace_clock", "global") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "set_event_pid", "5") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "set_ftrace_filter",
+ "schedule:stacktrace") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "set_ftrace_notrace",
+ "schedule:stacktrace") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "tracing_cpumask", "0f") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "events/syscalls/sys_exit_read/trigger",
+ "enable_event:kmem:kmalloc:1") > 0);
+ CU_TEST(tracefs_instance_file_write(instance, "events/bridge/fdb_delete/filter",
+ "common_pid == 5") > 0);
+
+ CU_TEST(test_instance_check_default_state(instance) == false);
+
+ tracefs_instance_reset(instance);
+ CU_TEST(test_instance_check_default_state(instance) == true);
+
+ CU_TEST(tracefs_instance_destroy(instance) == 0);
+ tracefs_instance_free(instance);
+}
+
static bool check_fd_name(int fd, const char *dir, const char *name)
{
char link[PATH_MAX + 1];
@@ -2354,6 +2535,8 @@ void test_tracefs_lib(void)
test_file_fd);
CU_add_test(suite, "instance file descriptor",
test_instance_file);
+ CU_add_test(suite, "instance reset",
+ test_instance_reset);
CU_add_test(suite, "systems and events APIs",
test_system_event);
CU_add_test(suite, "tracefs_iterate_raw_events API",
--
2.39.2
^ permalink raw reply related [flat|nested] 6+ messages in thread