Subject: [PATCH V8 00/14] RTLA: An interface for osnoise/timerlat tracers

The rtla(1) is a meta-tool that includes a set of commands that
aims to analyze the real-time properties of Linux. But instead of
testing Linux as a black box, rtla leverages kernel tracing
capabilities to provide precise information about the properties
and root causes of unexpected results.

To start, it presents an interface to the osnoise and timerlat tracers.
In the future, it will also serve as home to the rtsl [1] and other
latency/noise tracers.

If you just want to run it, you can download the tarball here:
- https://bristot.me/files/rtla/tarball/rtla-0.4.tar.bz2

To compile rtla on fedora you need:
$ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
$ cd libtraceevent/
$ make
$ sudo make install
$ cd ..
$ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
$ cd libtracefs/
$ make
$ sudo make install
$ cd ..
$ sudo dnf install python3-docutils procps-devel
$ cd $rtla_src
$ make
$ sudo make install

The tracing option (-t) depends some kernel patches that are
available at [2].

This tool was be discussed at the RT-MC during LPC2021 [3]

[1] rtsl: https://github.com/bristot/rtsl/
[2] https://lore.kernel.org/lkml/[email protected]/
[3] https://youtu.be/cZUzc0U1jJ4

Changes from V7:
- Add README.txt with information about how to compile the tool
(Steven)
- Use $$($(PKG_CONFIG) --libs libtracefs) to find libtracefs on
Makefile (Steven)
- Fix *buffer[4096] (using buffer[4096]) on save_trace_to_file()
(Steven)
Changes from v6:
- Revisited osnoise option config functions
- Properly handles offline CPUs
- Some cleanups
- Fixed an histogram allocation problem (Tao Zhou)
- Revisited open()/read()/write() (Tao Zhou)
Changes from v5:
- Fix retval check in save_trace_to_file() (Tao Zhou)
- Fix goto logic in save_trace_to_file() (Tao Zhou)
- Removed unused save_trace_pipe_to_file() function
- Correctly handle an error on osnoise_set_* functions during
"apply config" for all tools (Tao Zhou)
Changes from v3:
- Add cross-compile support (Ahmed S. Darwish)
- Move documentation to Documentation/tools/rtla (Jonathan Corbet)
- Use .rst format for documentation (Jonathan Corbet)
- Use include option from .rst to group common parts of the documentation
- Makefile (main and doc) cleanups
Changes from v2:
- Fix the miss conception of the "size" for kernel histograms (Steven/Tom)
- Change the --skip-zeros to --with-zeros option as the former is better
for humans (and the latter for computers to plot charts).
- A lot of checkpatch fixes for the user-space part.
Changes from v1:
- Fixes -t options on osnoise tracers (-t means --trace for all tools now)
- Fixes --bucket-size references (not --bucket_size)

Daniel Bristot de Oliveira (14):
rtla: Real-Time Linux Analysis tool
rtla: Helper functions for rtla
rtla: Add osnoise tool
rtla/osnoise: Add osnoise top mode
rtla/osnoise: Add the hist mode
rtla: Add timerlat tool and timelart top mode
rtla/timerlat: Add timerlat hist mode
rtla: Add Documentation
rtla: Add rtla osnoise man page
rtla: Add rtla osnoise top documentation
rtla: Add rtla osnoise hist documentation
rtla: Add rtla timerlat documentation
rtla: Add rtla timerlat top documentation
rtla: Add rtla timerlat hist documentation

Documentation/tools/rtla/Makefile | 41 +
Documentation/tools/rtla/common_appendix.rst | 12 +
.../tools/rtla/common_hist_options.rst | 23 +
Documentation/tools/rtla/common_options.rst | 24 +
.../tools/rtla/common_osnoise_description.rst | 8 +
.../tools/rtla/common_osnoise_options.rst | 17 +
.../rtla/common_timerlat_description.rst | 10 +
.../tools/rtla/common_timerlat_options.rst | 16 +
.../tools/rtla/common_top_options.rst | 3 +
.../tools/rtla/rtla-osnoise-hist.rst | 66 ++
Documentation/tools/rtla/rtla-osnoise-top.rst | 61 +
Documentation/tools/rtla/rtla-osnoise.rst | 59 +
.../tools/rtla/rtla-timerlat-hist.rst | 106 ++
.../tools/rtla/rtla-timerlat-top.rst | 145 +++
Documentation/tools/rtla/rtla-timerlat.rst | 57 +
Documentation/tools/rtla/rtla.rst | 48 +
tools/tracing/rtla/Makefile | 102 ++
tools/tracing/rtla/README.txt | 36 +
tools/tracing/rtla/src/osnoise.c | 1017 +++++++++++++++++
tools/tracing/rtla/src/osnoise.h | 96 ++
tools/tracing/rtla/src/osnoise_hist.c | 799 +++++++++++++
tools/tracing/rtla/src/osnoise_top.c | 577 ++++++++++
tools/tracing/rtla/src/rtla.c | 87 ++
tools/tracing/rtla/src/timerlat.c | 72 ++
tools/tracing/rtla/src/timerlat.h | 4 +
tools/tracing/rtla/src/timerlat_hist.c | 820 +++++++++++++
tools/tracing/rtla/src/timerlat_top.c | 615 ++++++++++
tools/tracing/rtla/src/trace.c | 192 ++++
tools/tracing/rtla/src/trace.h | 27 +
tools/tracing/rtla/src/utils.c | 433 +++++++
tools/tracing/rtla/src/utils.h | 56 +
31 files changed, 5629 insertions(+)
create mode 100644 Documentation/tools/rtla/Makefile
create mode 100644 Documentation/tools/rtla/common_appendix.rst
create mode 100644 Documentation/tools/rtla/common_hist_options.rst
create mode 100644 Documentation/tools/rtla/common_options.rst
create mode 100644 Documentation/tools/rtla/common_osnoise_description.rst
create mode 100644 Documentation/tools/rtla/common_osnoise_options.rst
create mode 100644 Documentation/tools/rtla/common_timerlat_description.rst
create mode 100644 Documentation/tools/rtla/common_timerlat_options.rst
create mode 100644 Documentation/tools/rtla/common_top_options.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise-hist.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise-top.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise.rst
create mode 100644 Documentation/tools/rtla/rtla-timerlat-hist.rst
create mode 100644 Documentation/tools/rtla/rtla-timerlat-top.rst
create mode 100644 Documentation/tools/rtla/rtla-timerlat.rst
create mode 100644 Documentation/tools/rtla/rtla.rst
create mode 100644 tools/tracing/rtla/Makefile
create mode 100644 tools/tracing/rtla/README.txt
create mode 100644 tools/tracing/rtla/src/osnoise.c
create mode 100644 tools/tracing/rtla/src/osnoise.h
create mode 100644 tools/tracing/rtla/src/osnoise_hist.c
create mode 100644 tools/tracing/rtla/src/osnoise_top.c
create mode 100644 tools/tracing/rtla/src/rtla.c
create mode 100644 tools/tracing/rtla/src/timerlat.c
create mode 100644 tools/tracing/rtla/src/timerlat.h
create mode 100644 tools/tracing/rtla/src/timerlat_hist.c
create mode 100644 tools/tracing/rtla/src/timerlat_top.c
create mode 100644 tools/tracing/rtla/src/trace.c
create mode 100644 tools/tracing/rtla/src/trace.h
create mode 100644 tools/tracing/rtla/src/utils.c
create mode 100644 tools/tracing/rtla/src/utils.h

--
2.31.1



Subject: [PATCH V8 01/14] rtla: Real-Time Linux Analysis tool

The rtla is a meta-tool that includes a set of commands that aims
to analyze the real-time properties of Linux. But instead of testing
Linux as a black box, rtla leverages kernel tracing capabilities to
provide precise information about the properties and root causes of
unexpected results.

rtla --help works and provide information about the available options.

This is just the "main" and the Makefile, no function yet.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/Makefile | 76 +++++++++++++++++++++++++++++++++++
tools/tracing/rtla/README.txt | 36 +++++++++++++++++
tools/tracing/rtla/src/rtla.c | 72 +++++++++++++++++++++++++++++++++
3 files changed, 184 insertions(+)
create mode 100644 tools/tracing/rtla/Makefile
create mode 100644 tools/tracing/rtla/README.txt
create mode 100644 tools/tracing/rtla/src/rtla.c

diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
new file mode 100644
index 000000000000..d99ea2d8b87e
--- /dev/null
+++ b/tools/tracing/rtla/Makefile
@@ -0,0 +1,76 @@
+NAME := rtla
+VERSION := 0.4
+
+# From libtracefs:
+# Makefiles suck: This macro sets a default value of $(2) for the
+# variable named by $(1), unless the variable has been set by
+# environment or command line. This is necessary for CC and AR
+# because make sets default values, so the simpler ?= approach
+# won't work as expected.
+define allow-override
+ $(if $(or $(findstring environment,$(origin $(1))),\
+ $(findstring command line,$(origin $(1)))),,\
+ $(eval $(1) = $(2)))
+endef
+
+# Allow setting CC and AR, or setting CROSS_COMPILE as a prefix.
+$(call allow-override,CC,$(CROSS_COMPILE)gcc)
+$(call allow-override,AR,$(CROSS_COMPILE)ar)
+$(call allow-override,STRIP,$(CROSS_COMPILE)strip)
+$(call allow-override,PKG_CONFIG,pkg-config)
+$(call allow-override,LD_SO_CONF_PATH,/etc/ld.so.conf.d/)
+$(call allow-override,LDCONFIG,ldconfig)
+
+INSTALL = install
+FOPTS := -flto=auto -ffat-lto-objects -fexceptions -fstack-protector-strong \
+ -fasynchronous-unwind-tables -fstack-clash-protection
+WOPTS := -Wall -Werror=format-security -Wp,-D_FORTIFY_SOURCE=2 -Wp,-D_GLIBCXX_ASSERTIONS -Wno-maybe-uninitialized
+
+TRACEFS_HEADERS := $$($(PKG_CONFIG) --cflags libtracefs)
+
+CFLAGS := -O -g -DVERSION=\"$(VERSION)\" $(FOPTS) $(MOPTS) $(WOPTS) $(TRACEFS_HEADERS)
+LDFLAGS := -ggdb
+LIBS := $$($(PKG_CONFIG) --libs libtracefs) -lprocps
+
+SRC := $(wildcard src/*.c)
+HDR := $(wildcard src/*.h)
+OBJ := $(SRC:.c=.o)
+DIRS := src
+FILES := Makefile README.txt
+CEXT := bz2
+TARBALL := $(NAME)-$(VERSION).tar.$(CEXT)
+TAROPTS := -cvjf $(TARBALL)
+BINDIR := /usr/bin
+DATADIR := /usr/share
+DOCDIR := $(DATADIR)/doc
+MANDIR := $(DATADIR)/man
+LICDIR := $(DATADIR)/licenses
+
+.PHONY: all
+all: rtla
+
+rtla: $(OBJ)
+ $(CC) -o rtla $(LDFLAGS) $(OBJ) $(LIBS)
+
+static: $(OBJ)
+ $(CC) -o rtla-static $(LDFLAGS) --static $(OBJ) $(LIBS) -lpthread -ldl
+
+.PHONY: install
+install:
+ $(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)
+ $(INSTALL) rtla -m 755 $(DESTDIR)$(BINDIR)
+ $(STRIP) $(DESTDIR)$(BINDIR)/rtla
+
+.PHONY: clean tarball
+clean:
+ @test ! -f rtla || rm rtla
+ @test ! -f rtla-static || rm rtla-static
+ @test ! -f src/rtla.o || rm src/rtla.o
+ @test ! -f $(TARBALL) || rm -f $(TARBALL)
+ @rm -rf *~ $(OBJ) *.tar.$(CEXT)
+
+tarball: clean
+ rm -rf $(NAME)-$(VERSION) && mkdir $(NAME)-$(VERSION)
+ cp -r $(DIRS) $(FILES) $(NAME)-$(VERSION)
+ tar $(TAROPTS) --exclude='*~' $(NAME)-$(VERSION)
+ rm -rf $(NAME)-$(VERSION)
diff --git a/tools/tracing/rtla/README.txt b/tools/tracing/rtla/README.txt
new file mode 100644
index 000000000000..6c88446f7e74
--- /dev/null
+++ b/tools/tracing/rtla/README.txt
@@ -0,0 +1,36 @@
+RTLA: Real-Time Linux Analysis tools
+
+The rtla is a meta-tool that includes a set of commands that
+aims to analyze the real-time properties of Linux. But, instead of
+testing Linux as a black box, rtla leverages kernel tracing
+capabilities to provide precise information about the properties
+and root causes of unexpected results.
+
+Installing RTLA
+
+RTLA depends on some libraries and tools. More precisely, it depends on the
+following libraries:
+
+ - libtracefs
+ - libtraceevent
+ - procps
+
+It also depends on python3-docutils to compile man pages.
+
+For development, we suggest the following steps for compiling rtla:
+
+ $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
+ $ cd libtraceevent/
+ $ make
+ $ sudo make install
+ $ cd ..
+ $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
+ $ cd libtracefs/
+ $ make
+ $ sudo make install
+ $ cd ..
+ $ cd $rtla_src
+ $ make
+ $ sudo make install
+
+For further information, please refer to the rtla man page.
diff --git a/tools/tracing/rtla/src/rtla.c b/tools/tracing/rtla/src/rtla.c
new file mode 100644
index 000000000000..5ae2664ed47d
--- /dev/null
+++ b/tools/tracing/rtla/src/rtla.c
@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+/*
+ * rtla_usage - print rtla usage
+ */
+static void rtla_usage(void)
+{
+ int i;
+
+ static const char *msg[] = {
+ "",
+ "rtla version " VERSION,
+ "",
+ " usage: rtla COMMAND ...",
+ "",
+ " commands:",
+ "",
+ NULL,
+ };
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+/*
+ * run_command - try to run a rtla tool command
+ *
+ * It returns 0 if it fails. The tool's main will generally not
+ * return as they should call exit().
+ */
+int run_command(int argc, char **argv, int start_position)
+{
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ int retval;
+
+ /* is it an alias? */
+ retval = run_command(argc, argv, 0);
+ if (retval)
+ exit(0);
+
+ if (argc < 2)
+ goto usage;
+
+ if (strcmp(argv[1], "-h") == 0) {
+ rtla_usage();
+ exit(0);
+ } else if (strcmp(argv[1], "--help") == 0) {
+ rtla_usage();
+ exit(0);
+ }
+
+ retval = run_command(argc, argv, 1);
+ if (retval)
+ exit(0);
+
+usage:
+ rtla_usage();
+ exit(1);
+}
--
2.31.1


Subject: [PATCH V8 02/14] rtla: Helper functions for rtla

This is a set of utils and tracer helper functions. They are used by
rtla mostly to parse config, display data and some trace operations that
are not part of libtracefs (because they are only useful it for this
case).

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/src/trace.c | 192 +++++++++++++++
tools/tracing/rtla/src/trace.h | 27 ++
tools/tracing/rtla/src/utils.c | 433 +++++++++++++++++++++++++++++++++
tools/tracing/rtla/src/utils.h | 56 +++++
4 files changed, 708 insertions(+)
create mode 100644 tools/tracing/rtla/src/trace.c
create mode 100644 tools/tracing/rtla/src/trace.h
create mode 100644 tools/tracing/rtla/src/utils.c
create mode 100644 tools/tracing/rtla/src/utils.h

diff --git a/tools/tracing/rtla/src/trace.c b/tools/tracing/rtla/src/trace.c
new file mode 100644
index 000000000000..a403cb4238bb
--- /dev/null
+++ b/tools/tracing/rtla/src/trace.c
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: GPL-2.0
+#define _GNU_SOURCE
+#include <sys/sendfile.h>
+#include <tracefs.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "trace.h"
+#include "utils.h"
+
+/*
+ * enable_tracer_by_name - enable a tracer on the given instance
+ */
+int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer)
+{
+ enum tracefs_tracers t;
+ int retval;
+
+ t = TRACEFS_TRACER_CUSTOM;
+
+ debug_msg("enabling %s tracer\n", tracer);
+
+ retval = tracefs_tracer_set(inst, t, tracer);
+ if (retval < 0) {
+ if (errno == ENODEV)
+ err_msg("tracer %s not found!\n", tracer);
+
+ err_msg("failed to enable the tracer %s\n", tracer);
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ * disable_tracer - set nop tracer to the insta
+ */
+void disable_tracer(struct tracefs_instance *inst)
+{
+ enum tracefs_tracers t = TRACEFS_TRACER_NOP;
+ int retval;
+
+ retval = tracefs_tracer_set(inst, t);
+ if (retval < 0)
+ err_msg("oops, error disabling tracer\n");
+}
+
+/*
+ * create_instance - create a trace instance with *instance_name
+ */
+struct tracefs_instance *create_instance(char *instance_name)
+{
+ return tracefs_instance_create(instance_name);
+}
+
+/*
+ * destroy_instance - remove a trace instance and free the data
+ */
+void destroy_instance(struct tracefs_instance *inst)
+{
+ tracefs_instance_destroy(inst);
+ tracefs_instance_free(inst);
+}
+
+/*
+ * save_trace_to_file - save the trace output of the instance to the file
+ */
+int save_trace_to_file(struct tracefs_instance *inst, const char *filename)
+{
+ const char *file = "trace";
+ mode_t mode = 0644;
+ char buffer[4096];
+ int out_fd, in_fd;
+ int retval = -1;
+
+ in_fd = tracefs_instance_file_open(inst, file, O_RDONLY);
+ if (in_fd < 0) {
+ err_msg("Failed to open trace file\n");
+ return -1;
+ }
+
+ out_fd = creat(filename, mode);
+ if (out_fd < 0) {
+ err_msg("Failed to create output file %s\n", filename);
+ goto out_close_in;
+ }
+
+ do {
+ retval = read(in_fd, buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ retval = write(out_fd, buffer, retval);
+ if (retval < 0)
+ goto out_close;
+ } while (retval > 0);
+
+ retval = 0;
+out_close:
+ close(out_fd);
+out_close_in:
+ close(in_fd);
+ return retval;
+}
+
+/*
+ * collect_registered_events - call the existing callback function for the event
+ *
+ * If an event has a registered callback function, call it.
+ * Otherwise, ignore the event.
+ */
+int
+collect_registered_events(struct tep_event *event, struct tep_record *record,
+ int cpu, void *context)
+{
+ struct trace_instance *trace = context;
+ struct trace_seq *s = trace->seq;
+
+ if (!event->handler)
+ return 0;
+
+ event->handler(s, record, event, context);
+
+ return 0;
+}
+
+/*
+ * trace_instance_destroy - destroy and free a rtla trace instance
+ */
+void trace_instance_destroy(struct trace_instance *trace)
+{
+ if (trace->inst) {
+ disable_tracer(trace->inst);
+ destroy_instance(trace->inst);
+ }
+
+ if (trace->seq)
+ free(trace->seq);
+
+ if (trace->tep)
+ tep_free(trace->tep);
+}
+
+/*
+ * trace_instance_init - create an rtla trace instance
+ *
+ * It is more than the tracefs instance, as it contains other
+ * things required for the tracing, such as the local events and
+ * a seq file.
+ *
+ * Note that the trace instance is returned disabled. This allows
+ * the tool to apply some other configs, like setting priority
+ * to the kernel threads, before starting generating trace entries.
+ */
+int trace_instance_init(struct trace_instance *trace, char *tool_name)
+{
+ trace->seq = calloc(1, sizeof(*trace->seq));
+ if (!trace->seq)
+ goto out_err;
+
+ trace_seq_init(trace->seq);
+
+ trace->inst = create_instance(tool_name);
+ if (!trace->inst)
+ goto out_err;
+
+ trace->tep = tracefs_local_events(NULL);
+ if (!trace->tep)
+ goto out_err;
+
+ /*
+ * Let the main enable the record after setting some other
+ * things such as the priority of the tracer's threads.
+ */
+ tracefs_trace_off(trace->inst);
+
+ return 0;
+
+out_err:
+ trace_instance_destroy(trace);
+ return 1;
+}
+
+/*
+ * trace_instance_start - start tracing a given rtla instance
+ */
+int trace_instance_start(struct trace_instance *trace)
+{
+ return tracefs_trace_on(trace->inst);
+}
diff --git a/tools/tracing/rtla/src/trace.h b/tools/tracing/rtla/src/trace.h
new file mode 100644
index 000000000000..7c3930909b70
--- /dev/null
+++ b/tools/tracing/rtla/src/trace.h
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <tracefs.h>
+#include <stddef.h>
+
+struct trace_instance {
+ struct tracefs_instance *inst;
+ struct tep_handle *tep;
+ struct trace_seq *seq;
+};
+
+int trace_instance_init(struct trace_instance *trace, char *tool_name);
+int trace_instance_start(struct trace_instance *trace);
+void trace_instance_destroy(struct trace_instance *trace);
+
+struct trace_seq *get_trace_seq(void);
+int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer);
+void disable_tracer(struct tracefs_instance *inst);
+
+int enable_osnoise(struct trace_instance *trace);
+int enable_timerlat(struct trace_instance *trace);
+
+struct tracefs_instance *create_instance(char *instance_name);
+void destroy_instance(struct tracefs_instance *inst);
+
+int save_trace_to_file(struct tracefs_instance *inst, const char *filename);
+int collect_registered_events(struct tep_event *tep, struct tep_record *record,
+ int cpu, void *context);
diff --git a/tools/tracing/rtla/src/utils.c b/tools/tracing/rtla/src/utils.c
new file mode 100644
index 000000000000..1c9f0eea6166
--- /dev/null
+++ b/tools/tracing/rtla/src/utils.c
@@ -0,0 +1,433 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <proc/readproc.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sched.h>
+#include <stdio.h>
+
+#include "utils.h"
+
+#define MAX_MSG_LENGTH 1024
+int config_debug;
+
+/*
+ * err_msg - print an error message to the stderr
+ */
+void err_msg(const char *fmt, ...)
+{
+ char message[MAX_MSG_LENGTH];
+ va_list ap;
+
+ va_start(ap, fmt);
+ vsnprintf(message, sizeof(message), fmt, ap);
+ va_end(ap);
+
+ fprintf(stderr, "%s", message);
+}
+
+/*
+ * debug_msg - print a debug message to stderr if debug is set
+ */
+void debug_msg(const char *fmt, ...)
+{
+ char message[MAX_MSG_LENGTH];
+ va_list ap;
+
+ if (!config_debug)
+ return;
+
+ va_start(ap, fmt);
+ vsnprintf(message, sizeof(message), fmt, ap);
+ va_end(ap);
+
+ fprintf(stderr, "%s", message);
+}
+
+/*
+ * get_llong_from_str - get a long long int from a string
+ */
+long long get_llong_from_str(char *start)
+{
+ long long value;
+ char *end;
+
+ errno = 0;
+ value = strtoll(start, &end, 10);
+ if (errno || start == end)
+ return -1;
+
+ return value;
+}
+
+/*
+ * get_duration - fill output with a human readable duration since start_time
+ */
+void get_duration(time_t start_time, char *output, int output_size)
+{
+ time_t now = time(NULL);
+ struct tm *tm_info;
+ time_t duration;
+
+ duration = difftime(now, start_time);
+ tm_info = localtime(&duration);
+
+ snprintf(output, output_size, "%3d %02d:%02d:%02d",
+ tm_info->tm_yday,
+ tm_info->tm_hour - 1,
+ tm_info->tm_min,
+ tm_info->tm_sec);
+}
+
+/*
+ * parse_cpu_list - parse a cpu_list filling a char vector with cpus set
+ *
+ * Receives a cpu list, like 1-3,5 (cpus 1, 2, 3, 5), and then set the char
+ * in the monitored_cpus.
+ *
+ * XXX: convert to a bitmask.
+ */
+int parse_cpu_list(char *cpu_list, char **monitored_cpus)
+{
+ char *mon_cpus;
+ const char *p;
+ int end_cpu;
+ int nr_cpus;
+ int cpu;
+ int i;
+
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ mon_cpus = malloc(nr_cpus * sizeof(char));
+ memset(mon_cpus, 0, (nr_cpus * sizeof(char)));
+
+ for (p = cpu_list; *p; ) {
+ cpu = atoi(p);
+ if (cpu < 0 || (!cpu && *p != '0') || cpu >= nr_cpus)
+ goto err;
+
+ while (isdigit(*p))
+ p++;
+ if (*p == '-') {
+ p++;
+ end_cpu = atoi(p);
+ if (end_cpu < cpu || (!end_cpu && *p != '0') || end_cpu >= nr_cpus)
+ goto err;
+ while (isdigit(*p))
+ p++;
+ } else
+ end_cpu = cpu;
+
+ if (cpu == end_cpu) {
+ debug_msg("cpu_list: adding cpu %d\n", cpu);
+ mon_cpus[cpu] = 1;
+ } else {
+ for (i = cpu; i <= end_cpu; i++) {
+ debug_msg("cpu_list: adding cpu %d\n", i);
+ mon_cpus[i] = 1;
+ }
+ }
+
+ if (*p == ',')
+ p++;
+ }
+
+ *monitored_cpus = mon_cpus;
+
+ return 0;
+
+err:
+ debug_msg("Error parsing the cpu list %s", cpu_list);
+ return 1;
+}
+
+/*
+ * parse_duration - parse duration with s/m/h/d suffix converting it to seconds
+ */
+long parse_seconds_duration(char *val)
+{
+ char *end;
+ long t;
+
+ t = strtol(val, &end, 10);
+
+ if (end) {
+ switch (*end) {
+ case 's':
+ case 'S':
+ break;
+ case 'm':
+ case 'M':
+ t *= 60;
+ break;
+ case 'h':
+ case 'H':
+ t *= 60 * 60;
+ break;
+
+ case 'd':
+ case 'D':
+ t *= 24 * 60 * 60;
+ break;
+ }
+ }
+
+ return t;
+}
+
+/*
+ * parse_ns_duration - parse duration with ns/us/ms/s converting it to nanoseconds
+ */
+long parse_ns_duration(char *val)
+{
+ char *end;
+ long t;
+
+ t = strtol(val, &end, 10);
+
+ if (end) {
+ if (!strncmp(end, "ns", 2)) {
+ return t;
+ } else if (!strncmp(end, "us", 2)) {
+ t *= 1000;
+ return t;
+ } else if (!strncmp(end, "ms", 2)) {
+ t *= 1000 * 1000;
+ return t;
+ } else if (!strncmp(end, "s", 1)) {
+ t *= 1000 * 1000 * 1000;
+ return t;
+ }
+ return -1;
+ }
+
+ return t;
+}
+
+/*
+ * This is a set of helper functions to use SCHED_DEADLINE.
+ */
+#ifdef __x86_64__
+# define __NR_sched_setattr 314
+# define __NR_sched_getattr 315
+#elif __i386__
+# define __NR_sched_setattr 351
+# define __NR_sched_getattr 352
+#elif __arm__
+# define __NR_sched_setattr 380
+# define __NR_sched_getattr 381
+#elif __aarch64__
+# define __NR_sched_setattr 274
+# define __NR_sched_getattr 275
+#elif __powerpc__
+# define __NR_sched_setattr 355
+# define __NR_sched_getattr 356
+#elif __s390x__
+# define __NR_sched_setattr 345
+# define __NR_sched_getattr 346
+#endif
+
+#define SCHED_DEADLINE 6
+
+static inline int sched_setattr(pid_t pid, const struct sched_attr *attr,
+ unsigned int flags) {
+ return syscall(__NR_sched_setattr, pid, attr, flags);
+}
+
+static inline int sched_getattr(pid_t pid, struct sched_attr *attr,
+ unsigned int size, unsigned int flags)
+{
+ return syscall(__NR_sched_getattr, pid, attr, size, flags);
+}
+
+int __set_sched_attr(int pid, struct sched_attr *attr)
+{
+ int flags = 0;
+ int retval;
+
+ retval = sched_setattr(pid, attr, flags);
+ if (retval < 0) {
+ err_msg("boost_with_deadline failed to boost pid %d: %s\n",
+ pid, strerror(errno));
+ return 1;
+ }
+
+ return 0;
+}
+/*
+ * set_comm_sched_attr - set sched params to threads starting with char *comm
+ *
+ * This function uses procps to list the currently running threads and then
+ * set the sched_attr *attr to the threads that start with char *comm. It is
+ * mainly used to set the priority to the kernel threads created by the
+ * tracers.
+ */
+int set_comm_sched_attr(const char *comm, struct sched_attr *attr)
+{
+ int flags = PROC_FILLCOM | PROC_FILLSTAT;
+ PROCTAB *ptp;
+ proc_t task;
+ int retval;
+
+ ptp = openproc(flags);
+ if (!ptp) {
+ err_msg("error openproc()\n");
+ return -ENOENT;
+ }
+
+ memset(&task, 0, sizeof(task));
+
+ while (readproc(ptp, &task)) {
+ retval = strncmp(comm, task.cmd, strlen(comm));
+ if (retval)
+ continue;
+ retval = __set_sched_attr(task.tid, attr);
+ if (retval)
+ goto out_err;
+ }
+
+ closeproc(ptp);
+ return 0;
+
+out_err:
+ closeproc(ptp);
+ return 1;
+}
+
+#define INVALID_VAL (~0L)
+static long get_long_ns_after_colon(char *start)
+{
+ long val = INVALID_VAL;
+
+ /* find the ":" */
+ start = strstr(start, ":");
+ if (!start)
+ return -1;
+
+ /* skip ":" */
+ start++;
+ val = parse_ns_duration(start);
+
+ return val;
+}
+
+static long get_long_after_colon(char *start)
+{
+ long val = INVALID_VAL;
+
+ /* find the ":" */
+ start = strstr(start, ":");
+ if (!start)
+ return -1;
+
+ /* skip ":" */
+ start++;
+ val = get_llong_from_str(start);
+
+ return val;
+}
+
+/*
+ * parse priority in the format:
+ * SCHED_OTHER:
+ * o:<prio>
+ * O:<prio>
+ * SCHED_RR:
+ * r:<prio>
+ * R:<prio>
+ * SCHED_FIFO:
+ * f:<prio>
+ * F:<prio>
+ * SCHED_DEADLINE:
+ * d:runtime:period
+ * D:runtime:period
+ */
+int parse_prio(char *arg, struct sched_attr *sched_param)
+{
+ long prio;
+ long runtime;
+ long period;
+
+ memset(sched_param, 0, sizeof(*sched_param));
+ sched_param->size = sizeof(*sched_param);
+
+ switch (arg[0]) {
+ case 'd':
+ case 'D':
+ /* d:runtime:period */
+ if (strlen(arg) < 4)
+ return -1;
+
+ runtime = get_long_ns_after_colon(arg);
+ if (runtime == INVALID_VAL)
+ return -1;
+
+ period = get_long_ns_after_colon(&arg[2]);
+ if (period == INVALID_VAL)
+ return -1;
+
+ if (runtime > period)
+ return -1;
+
+ sched_param->sched_policy = SCHED_DEADLINE;
+ sched_param->sched_runtime = runtime;
+ sched_param->sched_deadline = period;
+ sched_param->sched_period = period;
+ break;
+ case 'f':
+ case 'F':
+ /* f:prio */
+ prio = get_long_after_colon(arg);
+ if (prio == INVALID_VAL)
+ return -1;
+
+ if (prio < sched_get_priority_min(SCHED_FIFO))
+ return -1;
+ if (prio > sched_get_priority_max(SCHED_FIFO))
+ return -1;
+
+ sched_param->sched_policy = SCHED_FIFO;
+ sched_param->sched_priority = prio;
+ break;
+ case 'r':
+ case 'R':
+ /* r:prio */
+ prio = get_long_after_colon(arg);
+ if (prio == INVALID_VAL)
+ return -1;
+
+ if (prio < sched_get_priority_min(SCHED_RR))
+ return -1;
+ if (prio > sched_get_priority_max(SCHED_RR))
+ return -1;
+
+ sched_param->sched_policy = SCHED_RR;
+ sched_param->sched_priority = prio;
+ break;
+ case 'o':
+ case 'O':
+ /* o:prio */
+ prio = get_long_after_colon(arg);
+ if (prio == INVALID_VAL)
+ return -1;
+
+ if (prio < sched_get_priority_min(SCHED_OTHER))
+ return -1;
+ if (prio > sched_get_priority_max(SCHED_OTHER))
+ return -1;
+
+ sched_param->sched_policy = SCHED_OTHER;
+ sched_param->sched_priority = prio;
+ break;
+ default:
+ return -1;
+ }
+ return 0;
+}
diff --git a/tools/tracing/rtla/src/utils.h b/tools/tracing/rtla/src/utils.h
new file mode 100644
index 000000000000..9aa962319ca2
--- /dev/null
+++ b/tools/tracing/rtla/src/utils.h
@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <stdint.h>
+#include <time.h>
+
+/*
+ * '18446744073709551615\0'
+ */
+#define BUFF_U64_STR_SIZE 24
+
+#define container_of(ptr, type, member)({ \
+ const typeof(((type *)0)->member) *__mptr = (ptr); \
+ (type *)((char *)__mptr - offsetof(type, member)) ; })
+
+extern int config_debug;
+void debug_msg(const char *fmt, ...);
+void err_msg(const char *fmt, ...);
+
+long parse_seconds_duration(char *val);
+void get_duration(time_t start_time, char *output, int output_size);
+
+int parse_cpu_list(char *cpu_list, char **monitored_cpus);
+long long get_llong_from_str(char *start);
+
+static inline void
+update_min(unsigned long long *a, unsigned long long *b)
+{
+ if (*a > *b)
+ *a = *b;
+}
+
+static inline void
+update_max(unsigned long long *a, unsigned long long *b)
+{
+ if (*a < *b)
+ *a = *b;
+}
+
+static inline void
+update_sum(unsigned long long *a, unsigned long long *b)
+{
+ *a += *b;
+}
+
+struct sched_attr {
+ uint32_t size;
+ uint32_t sched_policy;
+ uint64_t sched_flags;
+ int32_t sched_nice;
+ uint32_t sched_priority;
+ uint64_t sched_runtime;
+ uint64_t sched_deadline;
+ uint64_t sched_period;
+};
+
+int parse_prio(char *arg, struct sched_attr *sched_param);
+int set_comm_sched_attr(const char *comm, struct sched_attr *attr);
--
2.31.1


Subject: [PATCH V8 03/14] rtla: Add osnoise tool

The osnoise tool is the interface for the osnoise tracer. The osnoise
tool will have multiple "modes" with different outputs. At this point,
no mode is included.

The osnoise.c includes the osnoise_context abstraction. It serves to
read-save-change-restore the default values from tracing/osnoise/
directory. When the context is deleted, the default values are restored.

It also includes some other helper functions for managing osnoise
tracer sessions.

With these bits and pieces in place, we can start adding some
functionality to rtla.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/Makefile | 2 +
tools/tracing/rtla/src/osnoise.c | 1013 ++++++++++++++++++++++++++++++
tools/tracing/rtla/src/osnoise.h | 95 +++
tools/tracing/rtla/src/rtla.c | 10 +
4 files changed, 1120 insertions(+)
create mode 100644 tools/tracing/rtla/src/osnoise.c
create mode 100644 tools/tracing/rtla/src/osnoise.h

diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
index d99ea2d8b87e..ba6f327e815a 100644
--- a/tools/tracing/rtla/Makefile
+++ b/tools/tracing/rtla/Makefile
@@ -60,6 +60,8 @@ install:
$(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)
$(INSTALL) rtla -m 755 $(DESTDIR)$(BINDIR)
$(STRIP) $(DESTDIR)$(BINDIR)/rtla
+ @test ! -f $(DESTDIR)$(BINDIR)/osnoise || rm $(DESTDIR)$(BINDIR)/osnoise
+ ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/osnoise

.PHONY: clean tarball
clean:
diff --git a/tools/tracing/rtla/src/osnoise.c b/tools/tracing/rtla/src/osnoise.c
new file mode 100644
index 000000000000..7ef686dddc09
--- /dev/null
+++ b/tools/tracing/rtla/src/osnoise.c
@@ -0,0 +1,1013 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include "osnoise.h"
+#include "utils.h"
+
+/*
+ * osnoise_get_cpus - return the original "osnoise/cpus" content
+ *
+ * It also saves the value to be restored.
+ */
+char *osnoise_get_cpus(struct osnoise_context *context)
+{
+ char buffer[1024];
+ char *cpus_path;
+ int retval;
+
+ if (context->curr_cpus)
+ return context->curr_cpus;
+
+ if (context->orig_cpus)
+ return context->orig_cpus;
+
+ cpus_path = tracefs_get_tracing_file("osnoise/cpus");
+
+ context->cpus_fd = open(cpus_path, O_RDWR);
+ if (context->cpus_fd < 0)
+ goto out_err;
+
+ retval = read(context->cpus_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ context->orig_cpus = strdup(buffer);
+ if (!context->orig_cpus)
+ goto out_close;
+
+ tracefs_put_tracing_file(cpus_path);
+
+ return context->orig_cpus;
+
+out_close:
+ close(context->cpus_fd);
+out_err:
+ tracefs_put_tracing_file(cpus_path);
+ return NULL;
+}
+
+/*
+ * osnoise_set_cpus - configure osnoise to run on *cpus
+ *
+ * "osnoise/cpus" file is used to set the cpus in which osnoise/timerlat
+ * will run. This function opens this file, saves the current value,
+ * and set the cpus passed as argument.
+ */
+int osnoise_set_cpus(struct osnoise_context *context, char *cpus)
+{
+ char *orig_cpus = osnoise_get_cpus(context);
+ int retval;
+
+ if (!orig_cpus)
+ return -1;
+
+ context->curr_cpus = strdup(cpus);
+ if (!context->curr_cpus)
+ return -1;
+
+ retval = write(context->cpus_fd, cpus, strlen(cpus) + 1);
+ if (retval < (strlen(cpus) + 1)) {
+ free(context->curr_cpus);
+ context->curr_cpus = NULL;
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_cpus - restore the original "osnoise/cpus"
+ *
+ * osnoise_set_cpus() saves the original data for the "osnoise/cpus"
+ * file. This function restore the original config it was previously
+ * modified.
+ */
+void osnoise_restore_cpus(struct osnoise_context *context)
+{
+ int retval;
+
+ if (!context->orig_cpus)
+ return;
+
+ if (!context->curr_cpus)
+ return;
+
+ /* nothing to do? */
+ if (!strcmp(context->orig_cpus, context->curr_cpus))
+ goto out_done;
+
+ retval = write(context->cpus_fd, context->orig_cpus, strlen(context->orig_cpus));
+ if (retval < strlen(context->orig_cpus))
+ err_msg("could not restore original osnoise cpus\n");
+
+out_done:
+ free(context->curr_cpus);
+ context->curr_cpus = NULL;
+}
+
+/*
+ * osnoise_put_cpus - restore cpus config and cleanup data
+ */
+void osnoise_put_cpus(struct osnoise_context *context)
+{
+ osnoise_restore_cpus(context);
+
+ if (!context->orig_cpus)
+ return;
+
+ free(context->orig_cpus);
+ context->orig_cpus = NULL;
+ close(context->cpus_fd);
+ context->cpus_fd = CLOSED_FD;
+}
+
+/*
+ * osnoise_get_runtime - return the original "osnoise/runtime_us" value
+ *
+ * It also saves the value to be restored.
+ */
+unsigned long long osnoise_get_runtime(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ long long runtime_us;
+ char *runtime_path;
+ int retval;
+
+ if (context->runtime_us != OSNOISE_TIME_INIT_VAL)
+ return context->runtime_us;
+
+ if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
+ return context->orig_runtime_us;
+
+ runtime_path = tracefs_get_tracing_file("osnoise/runtime_us");
+
+ context->runtime_fd = open(runtime_path, O_RDWR);
+ if (context->runtime_fd < 0)
+ goto out_err;
+
+ retval = read(context->runtime_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ runtime_us = get_llong_from_str(buffer);
+ if (runtime_us < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(runtime_path);
+
+ context->orig_runtime_us = runtime_us;
+ return runtime_us;
+
+out_close:
+ close(context->runtime_fd);
+ context->runtime_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(runtime_path);
+ return 0;
+}
+
+/*
+ * osnoise_get_period - return the original "osnoise/period_us" value
+ *
+ * It also saves the value to be restored.
+ */
+unsigned long long osnoise_get_period(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ char *period_path;
+ long long period_us;
+ int retval;
+
+ if (context->period_us != OSNOISE_TIME_INIT_VAL)
+ return context->period_us;
+
+ if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
+ return context->orig_period_us;
+
+ period_path = tracefs_get_tracing_file("osnoise/period_us");
+
+ context->period_fd = open(period_path, O_RDWR);
+ if (context->period_fd < 0)
+ goto out_err;
+
+ retval = read(context->period_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ period_us = get_llong_from_str(buffer);
+ if (period_us < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(period_path);
+
+ context->orig_period_us = period_us;
+ return period_us;
+
+out_close:
+ close(context->period_fd);
+ context->period_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(period_path);
+ return 0;
+}
+
+static int __osnoise_write_runtime(struct osnoise_context *context,
+ unsigned long long runtime)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_runtime_us == OSNOISE_TIME_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, sizeof(buffer), "%llu\n", runtime);
+
+ retval = write(context->runtime_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->runtime_us = runtime;
+ return 0;
+}
+
+static int __osnoise_write_period(struct osnoise_context *context,
+ unsigned long long period)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_period_us == OSNOISE_TIME_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, sizeof(buffer), "%llu\n", period);
+
+ retval = write(context->period_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->period_us = period;
+ return 0;
+}
+
+/*
+ * osnoise_set_runtime_period - set osnoise runtime and period
+ *
+ * Osnoise's runtime and period are related as runtime <= period.
+ * Thus, this function saves the original values, and then tries
+ * to set the runtime and period if they are != 0.
+ */
+int osnoise_set_runtime_period(struct osnoise_context *context,
+ unsigned long long runtime,
+ unsigned long long period)
+{
+ unsigned long long curr_runtime_us;
+ unsigned long long curr_period_us;
+ int retval;
+
+ if (!period && !runtime)
+ return 0;
+
+ curr_runtime_us = osnoise_get_runtime(context);
+ curr_period_us = osnoise_get_period(context);
+
+ /* error getting any value? */
+ if (curr_period_us == -1 || curr_runtime_us == -1)
+ return -1;
+
+ if (!period) {
+ if (runtime > curr_period_us)
+ return -1;
+ return __osnoise_write_runtime(context, runtime);
+ } else if (!runtime) {
+ if (period < curr_runtime_us)
+ return -1;
+ return __osnoise_write_period(context, period);
+ }
+
+ if (runtime > curr_period_us) {
+ retval = __osnoise_write_period(context, period);
+ if (retval)
+ return -1;
+ retval = __osnoise_write_runtime(context, runtime);
+ if (retval)
+ return -1;
+ } else {
+ retval = __osnoise_write_runtime(context, runtime);
+ if (retval)
+ return -1;
+ retval = __osnoise_write_period(context, period);
+ if (retval)
+ return -1;
+ }
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_runtime_period - restore the original runtime and period
+ */
+void osnoise_restore_runtime_period(struct osnoise_context *context)
+{
+ unsigned long long orig_runtime = context->orig_runtime_us;
+ unsigned long long orig_period = context->orig_period_us;
+ unsigned long long curr_runtime = context->runtime_us;
+ unsigned long long curr_period = context->period_us;
+ int retval;
+
+ if ((orig_runtime == OSNOISE_TIME_INIT_VAL) && (orig_period == OSNOISE_TIME_INIT_VAL))
+ return;
+
+ if ((orig_period == curr_period) && (orig_runtime == curr_runtime))
+ goto out_done;
+
+ retval = osnoise_set_runtime_period(context, orig_runtime, orig_period);
+ if (retval)
+ err_msg("Could not restore original osnoise runtime/period\n");
+
+out_done:
+ context->runtime_us = OSNOISE_TIME_INIT_VAL;
+ context->period_us = OSNOISE_TIME_INIT_VAL;
+}
+
+/*
+ * osnoise_put_runtime_period - restore original values and cleanup data
+ */
+void osnoise_put_runtime_period(struct osnoise_context *context)
+{
+ osnoise_restore_runtime_period(context);
+
+ if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL) {
+ close(context->runtime_fd);
+ context->runtime_fd = CLOSED_FD;
+ context->orig_runtime_us = OSNOISE_TIME_INIT_VAL;
+ }
+
+ if (context->orig_period_us != OSNOISE_TIME_INIT_VAL) {
+ close(context->period_fd);
+ context->period_fd = CLOSED_FD;
+ context->orig_period_us = OSNOISE_TIME_INIT_VAL;
+ }
+}
+
+/*
+ * osnoise_get_timerlat_period_us - read and save the original "timerlat_period_us"
+ */
+static long long
+osnoise_get_timerlat_period_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ long long timerlat_period_us;
+ char *stop_path;
+ int retval;
+
+ if (context->timerlat_period_us != OSNOISE_TIME_INIT_VAL)
+ return context->timerlat_period_us;
+
+ if (context->orig_timerlat_period_us != OSNOISE_TIME_INIT_VAL)
+ return context->orig_timerlat_period_us;
+
+ stop_path = tracefs_get_tracing_file("osnoise/timerlat_period_us");
+
+ context->timerlat_period_us_fd = open(stop_path, O_RDWR);
+ if (context->timerlat_period_us_fd < 0)
+ goto out_err;
+
+ retval = read(context->timerlat_period_us_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ timerlat_period_us = get_llong_from_str(buffer);
+ if (timerlat_period_us < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(stop_path);
+
+ context->orig_timerlat_period_us = timerlat_period_us;
+ return timerlat_period_us;
+
+out_close:
+ close(context->timerlat_period_us_fd);
+ context->timerlat_period_us_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(stop_path);
+ return -1;
+}
+
+/*
+ * osnoise_set_timerlat_period_us - set "timerlat_period_us"
+ */
+int osnoise_set_timerlat_period_us(struct osnoise_context *context, long long timerlat_period_us)
+{
+ long long curr_timerlat_period_us = osnoise_get_timerlat_period_us(context);
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (curr_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", timerlat_period_us);
+
+ retval = write(context->timerlat_period_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->timerlat_period_us = timerlat_period_us;
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_timerlat_period_us - restore "timerlat_period_us"
+ */
+void osnoise_restore_timerlat_period_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
+ return;
+
+ if (context->orig_timerlat_period_us == context->timerlat_period_us)
+ goto out_done;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_timerlat_period_us);
+
+ retval = write(context->timerlat_period_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ err_msg("Could not restore original osnoise timerlat_period_us\n");
+
+out_done:
+ context->timerlat_period_us = OSNOISE_TIME_INIT_VAL;
+}
+
+/*
+ * osnoise_put_timerlat_period_us - restore original values and cleanup data
+ */
+void osnoise_put_timerlat_period_us(struct osnoise_context *context)
+{
+ osnoise_restore_timerlat_period_us(context);
+
+ if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
+ return;
+
+ close(context->timerlat_period_us_fd);
+ context->timerlat_period_us_fd = CLOSED_FD;
+ context->orig_timerlat_period_us = OSNOISE_TIME_INIT_VAL;
+}
+
+/*
+ * osnoise_get_stop_us - read and save the original "stop_tracing_us"
+ */
+static long long
+osnoise_get_stop_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ long long stop_us;
+ char *stop_path;
+ int retval;
+
+ if (context->stop_us != OSNOISE_OPTION_INIT_VAL)
+ return context->stop_us;
+
+ if (context->orig_stop_us != OSNOISE_OPTION_INIT_VAL)
+ return context->orig_stop_us;
+
+ stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_us");
+
+ context->stop_us_fd = open(stop_path, O_RDWR);
+ if (context->stop_us_fd < 0)
+ goto out_err;
+
+ retval = read(context->stop_us_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ stop_us = get_llong_from_str(buffer);
+ if (stop_us < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(stop_path);
+
+ context->orig_stop_us = stop_us;
+ return stop_us;
+
+out_close:
+ close(context->stop_us_fd);
+ context->stop_us_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(stop_path);
+ return -1;
+}
+
+/*
+ * osnoise_set_stop_us - set "stop_tracing_us"
+ */
+int osnoise_set_stop_us(struct osnoise_context *context, long long stop_us)
+{
+ long long curr_stop_us = osnoise_get_stop_us(context);
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (curr_stop_us == OSNOISE_OPTION_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", stop_us);
+
+ retval = write(context->stop_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->stop_us = stop_us;
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_stop_us - restore the original "stop_tracing_us"
+ */
+void osnoise_restore_stop_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ if (context->orig_stop_us == context->stop_us)
+ goto out_done;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_stop_us);
+
+ retval = write(context->stop_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ err_msg("Could not restore original osnoise stop_us\n");
+
+out_done:
+ context->stop_us = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * osnoise_put_stop_us - restore original values and cleanup data
+ */
+void osnoise_put_stop_us(struct osnoise_context *context)
+{
+ osnoise_restore_stop_us(context);
+
+ if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ close(context->stop_us_fd);
+ context->stop_us_fd = CLOSED_FD;
+ context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * osnoise_get_stop_total_us - read and save the original "stop_tracing_total_us"
+ */
+static long long
+osnoise_get_stop_total_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ long long stop_total_us;
+ char *stop_path;
+ int retval;
+
+ if (context->stop_total_us != OSNOISE_OPTION_INIT_VAL)
+ return context->stop_total_us;
+
+ if (context->orig_stop_total_us != OSNOISE_OPTION_INIT_VAL)
+ return context->orig_stop_total_us;
+
+ stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_total_us");
+
+ context->stop_total_us_fd = open(stop_path, O_RDWR);
+ if (context->stop_total_us_fd < 0)
+ goto out_err;
+
+ retval = read(context->stop_total_us_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ stop_total_us = get_llong_from_str(buffer);
+ if (stop_total_us < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(stop_path);
+
+ context->orig_stop_total_us = stop_total_us;
+ return stop_total_us;
+
+out_close:
+ close(context->stop_total_us_fd);
+ context->stop_total_us_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(stop_path);
+ return -1;
+}
+
+/*
+ * osnoise_set_stop_total_us - set "stop_tracing_total_us"
+ */
+int osnoise_set_stop_total_us(struct osnoise_context *context, long long stop_total_us)
+{
+ long long curr_stop_total_us = osnoise_get_stop_total_us(context);
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (curr_stop_total_us == OSNOISE_OPTION_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", stop_total_us);
+
+ retval = write(context->stop_total_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->stop_total_us = stop_total_us;
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_stop_total_us - restore the original "stop_tracing_total_us"
+ */
+void osnoise_restore_stop_total_us(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ if (context->orig_stop_total_us == context->stop_total_us)
+ goto out_done;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_stop_total_us);
+
+ retval = write(context->stop_total_us_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ err_msg("Could not restore original osnoise stop_total_us\n");
+
+out_done:
+ context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * osnoise_put_stop_total_us - restore original values and cleanup data
+ */
+void osnoise_put_stop_total_us(struct osnoise_context *context)
+{
+ osnoise_restore_stop_total_us(context);
+
+ if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ close(context->stop_total_us_fd);
+ context->stop_total_us_fd = CLOSED_FD;
+ context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * osnoise_get_print_stack - read and save the original "print_stack"
+ */
+static long long
+osnoise_get_print_stack(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ long long print_stack;
+ char *stop_path;
+ int retval;
+
+ if (context->print_stack != OSNOISE_OPTION_INIT_VAL)
+ return context->print_stack;
+
+ if (context->orig_print_stack != OSNOISE_OPTION_INIT_VAL)
+ return context->orig_print_stack;
+
+ stop_path = tracefs_get_tracing_file("osnoise/print_stack");
+
+ context->print_stack_fd = open(stop_path, O_RDWR);
+ if (context->print_stack_fd < 0)
+ goto out_err;
+
+ retval = read(context->print_stack_fd, &buffer, sizeof(buffer));
+ if (retval <= 0)
+ goto out_close;
+
+ print_stack = get_llong_from_str(buffer);
+ if (print_stack < 0)
+ goto out_close;
+
+ tracefs_put_tracing_file(stop_path);
+
+ context->orig_print_stack = print_stack;
+ return print_stack;
+
+out_close:
+ close(context->print_stack_fd);
+ context->print_stack_fd = CLOSED_FD;
+out_err:
+ tracefs_put_tracing_file(stop_path);
+ return -1;
+}
+
+/*
+ * osnoise_set_print_stack - set "print_stack"
+ */
+int osnoise_set_print_stack(struct osnoise_context *context, long long print_stack)
+{
+ long long curr_print_stack = osnoise_get_print_stack(context);
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (curr_print_stack == OSNOISE_OPTION_INIT_VAL)
+ return -1;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", print_stack);
+
+ retval = write(context->print_stack_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ return -1;
+
+ context->print_stack = print_stack;
+
+ return 0;
+}
+
+/*
+ * osnoise_restore_print_stack - restore the original "print_stack"
+ */
+void osnoise_restore_print_stack(struct osnoise_context *context)
+{
+ char buffer[BUFF_U64_STR_SIZE];
+ int retval;
+
+ if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ if (context->orig_print_stack == context->print_stack)
+ goto out_done;
+
+ snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_print_stack);
+
+ retval = write(context->print_stack_fd, buffer, strlen(buffer) + 1);
+ if (retval < (strlen(buffer) + 1))
+ err_msg("Could not restore original osnoise print_stack\n");
+
+out_done:
+ context->print_stack = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * osnoise_put_print_stack - restore original values and cleanup data
+ */
+void osnoise_put_print_stack(struct osnoise_context *context)
+{
+ osnoise_restore_print_stack(context);
+
+ if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
+ return;
+
+ close(context->print_stack_fd);
+ context->print_stack_fd = CLOSED_FD;
+ context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
+}
+
+/*
+ * enable_osnoise - enable osnoise tracer in the trace_instance
+ */
+int enable_osnoise(struct trace_instance *trace)
+{
+ return enable_tracer_by_name(trace->inst, "osnoise");
+}
+
+/*
+ * enable_timerlat - enable timerlat tracer in the trace_instance
+ */
+int enable_timerlat(struct trace_instance *trace)
+{
+ return enable_tracer_by_name(trace->inst, "timerlat");
+}
+
+enum {
+ FLAG_CONTEXT_NEWLY_CREATED = (1 << 0),
+ FLAG_CONTEXT_DELETED = (1 << 1),
+};
+
+/*
+ * osnoise_get_context - increase the usage of a context and return it
+ */
+int osnoise_get_context(struct osnoise_context *context)
+{
+ int ret;
+
+ if (context->flags & FLAG_CONTEXT_DELETED) {
+ ret = -1;
+ } else {
+ context->ref++;
+ ret = 0;
+ }
+
+ return ret;
+}
+
+/*
+ * osnoise_context_alloc - alloc an osnoise_context
+ *
+ * The osnoise context contains the information of the "osnoise/" configs.
+ * It is used to set and restore the config.
+ */
+struct osnoise_context *osnoise_context_alloc(void)
+{
+ struct osnoise_context *context;
+
+ context = calloc(1, sizeof(*context));
+ if (!context)
+ goto out_err;
+
+ context->cpus_fd = CLOSED_FD;
+ context->runtime_fd = CLOSED_FD;
+ context->period_fd = CLOSED_FD;
+ context->stop_us_fd = CLOSED_FD;
+ context->stop_total_us_fd = CLOSED_FD;
+ context->timerlat_period_us_fd = CLOSED_FD;
+ context->print_stack_fd = CLOSED_FD;
+
+ context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
+ context->stop_us = OSNOISE_OPTION_INIT_VAL;
+
+ context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
+ context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
+
+ context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
+ context->print_stack = OSNOISE_OPTION_INIT_VAL;
+
+ osnoise_get_context(context);
+
+ return context;
+out_err:
+ if (context)
+ free(context);
+ return NULL;
+}
+
+/*
+ * osnoise_put_context - put the osnoise_put_context
+ *
+ * If there is no other user for the context, the original data
+ * is restored.
+ */
+void osnoise_put_context(struct osnoise_context *context)
+{
+ if (--context->ref < 1)
+ context->flags |= FLAG_CONTEXT_DELETED;
+
+ if (!(context->flags & FLAG_CONTEXT_DELETED))
+ return;
+
+ osnoise_put_cpus(context);
+ osnoise_put_runtime_period(context);
+ osnoise_put_stop_us(context);
+ osnoise_put_stop_total_us(context);
+ osnoise_put_timerlat_period_us(context);
+ osnoise_put_print_stack(context);
+
+ free(context);
+}
+
+/*
+ * osnoise_destroy_tool - disable trace, restore configs and free data
+ */
+void osnoise_destroy_tool(struct osnoise_tool *top)
+{
+ trace_instance_destroy(&top->trace);
+
+ if (top->context)
+ osnoise_put_context(top->context);
+
+ free(top);
+}
+
+/*
+ * osnoise_init_tool - init an osnoise tool
+ *
+ * It allocs data, create a context to store data and
+ * creates a new trace instance for the tool.
+ */
+struct osnoise_tool *osnoise_init_tool(char *tool_name)
+{
+ struct osnoise_tool *top;
+ int retval;
+
+ top = calloc(1, sizeof(*top));
+ if (!top)
+ return NULL;
+
+ top->context = osnoise_context_alloc();
+ if (!top->context)
+ goto out_err;
+
+ retval = trace_instance_init(&top->trace, tool_name);
+ if (retval)
+ goto out_err;
+
+ return top;
+out_err:
+ osnoise_destroy_tool(top);
+ return NULL;
+}
+
+/*
+ * osnoise_init_trace_tool - init a tracer instance to trace osnoise events
+ */
+struct osnoise_tool *osnoise_init_trace_tool(char *tracer)
+{
+ struct osnoise_tool *trace;
+ int retval;
+
+ trace = osnoise_init_tool("osnoise_trace");
+ if (!trace)
+ return NULL;
+
+ retval = tracefs_event_enable(trace->trace.inst, "osnoise", NULL);
+ if (retval < 0 && !errno) {
+ err_msg("Could not find osnoise events\n");
+ goto out_err;
+ }
+
+ retval = enable_tracer_by_name(trace->trace.inst, tracer);
+ if (retval) {
+ err_msg("Could not enable osnoiser tracer for tracing\n");
+ goto out_err;
+ }
+
+ return trace;
+out_err:
+ osnoise_destroy_tool(trace);
+ return NULL;
+}
+
+static void osnoise_usage(void)
+{
+ int i;
+
+ static const char *msg[] = {
+ "",
+ "osnoise version " VERSION,
+ "",
+ " usage: [rtla] osnoise [MODE] ...",
+ "",
+ " modes:",
+ " top - prints the summary from osnoise tracer",
+ "",
+ "if no MODE is given, the top mode is called, passing the arguments",
+ NULL,
+ };
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+int osnoise_main(int argc, char *argv[])
+{
+ if (argc == 0)
+ goto usage;
+
+ /*
+ * if osnoise was called without any argument, run the
+ * default cmdline.
+ */
+ if (argc == 1) {
+ osnoise_top_main(argc, argv);
+ exit(0);
+ }
+
+ if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
+ osnoise_usage();
+ exit(0);
+ } else if (strncmp(argv[1], "-", 1) == 0) {
+ /* the user skipped the tool, call the default one */
+ osnoise_top_main(argc, argv);
+ exit(0);
+ } else if (strcmp(argv[1], "top") == 0) {
+ osnoise_top_main(argc-1, &argv[1]);
+ exit(0);
+ }
+
+usage:
+ osnoise_usage();
+ exit(1);
+}
diff --git a/tools/tracing/rtla/src/osnoise.h b/tools/tracing/rtla/src/osnoise.h
new file mode 100644
index 000000000000..e3e8f8359d99
--- /dev/null
+++ b/tools/tracing/rtla/src/osnoise.h
@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: GPL-2.0
+#include "trace.h"
+
+/*
+ * osnoise_context - read, store, write, restore osnoise configs.
+ */
+struct osnoise_context {
+ int flags;
+ int ref;
+
+ int cpus_fd;
+ int runtime_fd;
+ int period_fd;
+ int stop_us_fd;
+ int stop_total_us_fd;
+ int timerlat_period_us_fd;
+ int print_stack_fd;
+
+ char *curr_cpus;
+ char *orig_cpus;
+
+ /* 0 as init value */
+ unsigned long long orig_runtime_us;
+ unsigned long long runtime_us;
+
+ /* 0 as init value */
+ unsigned long long orig_period_us;
+ unsigned long long period_us;
+
+ /* 0 as init value */
+ long long orig_timerlat_period_us;
+ long long timerlat_period_us;
+
+ /* -1 as init value because 0 is disabled */
+ long long orig_stop_us;
+ long long stop_us;
+
+ /* -1 as init value because 0 is disabled */
+ long long orig_stop_total_us;
+ long long stop_total_us;
+
+ /* -1 as init value because 0 is disabled */
+ long long orig_print_stack;
+ long long print_stack;
+};
+
+#define CLOSED_FD (-1)
+#define OSNOISE_OPTION_INIT_VAL (-1)
+#define OSNOISE_TIME_INIT_VAL (0)
+
+struct osnoise_context *osnoise_context_alloc(void);
+int osnoise_get_context(struct osnoise_context *context);
+void osnoise_put_context(struct osnoise_context *context);
+
+int osnoise_set_cpus(struct osnoise_context *context, char *cpus);
+void osnoise_restore_cpus(struct osnoise_context *context);
+
+int osnoise_set_runtime_period(struct osnoise_context *context,
+ unsigned long long runtime,
+ unsigned long long period);
+void osnoise_restore_runtime_period(struct osnoise_context *context);
+
+int osnoise_set_stop_us(struct osnoise_context *context,
+ long long stop_us);
+void osnoise_restore_stop_us(struct osnoise_context *context);
+
+int osnoise_set_stop_total_us(struct osnoise_context *context,
+ long long stop_total_us);
+void osnoise_restore_stop_total_us(struct osnoise_context *context);
+
+int osnoise_set_timerlat_period_us(struct osnoise_context *context,
+ long long timerlat_period_us);
+void osnoise_restore_timerlat_period_us(struct osnoise_context *context);
+
+void osnoise_restore_print_stack(struct osnoise_context *context);
+int osnoise_set_print_stack(struct osnoise_context *context,
+ long long print_stack);
+
+/*
+ * osnoise_tool - osnoise based tool definition.
+ */
+struct osnoise_tool {
+ struct trace_instance trace;
+ struct osnoise_context *context;
+ void *data;
+ void *params;
+ time_t start_time;
+};
+
+void osnoise_destroy_tool(struct osnoise_tool *top);
+struct osnoise_tool *osnoise_init_tool(char *tool_name);
+struct osnoise_tool *osnoise_init_trace_tool(char *tracer);
+
+int osnoise_top_main(int argc, char **argv);
+int osnoise_main(int argc, char **argv);
diff --git a/tools/tracing/rtla/src/rtla.c b/tools/tracing/rtla/src/rtla.c
index 5ae2664ed47d..669b9750b3b3 100644
--- a/tools/tracing/rtla/src/rtla.c
+++ b/tools/tracing/rtla/src/rtla.c
@@ -8,6 +8,8 @@
#include <string.h>
#include <stdio.h>

+#include "osnoise.h"
+
/*
* rtla_usage - print rtla usage
*/
@@ -22,6 +24,7 @@ static void rtla_usage(void)
" usage: rtla COMMAND ...",
"",
" commands:",
+ " osnoise - gives information about the operating system noise (osnoise)",
"",
NULL,
};
@@ -39,7 +42,14 @@ static void rtla_usage(void)
*/
int run_command(int argc, char **argv, int start_position)
{
+ if (strcmp(argv[start_position], "osnoise") == 0) {
+ osnoise_main(argc-start_position, &argv[start_position]);
+ goto ran;
+ }
+
return 0;
+ran:
+ return 1;
}

int main(int argc, char *argv[])
--
2.31.1


Subject: [PATCH V8 04/14] rtla/osnoise: Add osnoise top mode

The rtla osnoise tool is an interface for the osnoise tracer. The
osnoise tracer dispatches a kernel thread per-cpu. These threads read
the time in a loop while with preemption, softirqs and IRQs enabled,
thus allowing all the sources of osnoise during its execution. The
osnoise threads take note of the entry and exit point of any source
of interferences, increasing a per-cpu interference counter. The
osnoise tracer also saves an interference counter for each source
of interference.

The rtla osnoise top mode displays information about the periodic
summary from the osnoise tracer.

One example of rtla osnoise top output is:

[root@alien ~]# rtla osnoise top -c 0-3 -d 1m -q -r 900000 -P F:1
Operating System Noise
duration: 0 00:01:00 | time is in us
CPU Period Runtime Noise % CPU Aval Max Noise Max Single HW NMI IRQ Softirq Thread
0 #58 52200000 1031 99.99802 91 60 0 0 52285 0 101
1 #59 53100000 5 99.99999 5 5 0 9 53122 0 18
2 #59 53100000 7 99.99998 7 7 0 8 53115 0 18
3 #59 53100000 8274 99.98441 277 23 0 9 53778 0 660

"rtla osnoise top --help" works and provide information about the
available options.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/src/osnoise_top.c | 577 +++++++++++++++++++++++++++
1 file changed, 577 insertions(+)
create mode 100644 tools/tracing/rtla/src/osnoise_top.c

diff --git a/tools/tracing/rtla/src/osnoise_top.c b/tools/tracing/rtla/src/osnoise_top.c
new file mode 100644
index 000000000000..e23bae8d9696
--- /dev/null
+++ b/tools/tracing/rtla/src/osnoise_top.c
@@ -0,0 +1,577 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "osnoise.h"
+#include "utils.h"
+
+/*
+ * osnoise top parameters
+ */
+struct osnoise_top_params {
+ char *cpus;
+ char *monitored_cpus;
+ char *trace_output;
+ unsigned long long runtime;
+ unsigned long long period;
+ long long stop_us;
+ long long stop_total_us;
+ int sleep_time;
+ int duration;
+ int quiet;
+ int set_sched;
+ struct sched_attr sched_param;
+};
+
+struct osnoise_top_cpu {
+ unsigned long long sum_runtime;
+ unsigned long long sum_noise;
+ unsigned long long max_noise;
+ unsigned long long max_sample;
+
+ unsigned long long hw_count;
+ unsigned long long nmi_count;
+ unsigned long long irq_count;
+ unsigned long long softirq_count;
+ unsigned long long thread_count;
+
+ int sum_cycles;
+};
+
+struct osnoise_top_data {
+ struct osnoise_top_cpu *cpu_data;
+ int nr_cpus;
+};
+
+/*
+ * osnoise_free_top - free runtime data
+ */
+static void
+osnoise_free_top(struct osnoise_top_data *data)
+{
+ free(data->cpu_data);
+ free(data);
+}
+
+/*
+ * osnoise_alloc_histogram - alloc runtime data
+ */
+static struct osnoise_top_data *osnoise_alloc_top(int nr_cpus)
+{
+ struct osnoise_top_data *data;
+
+ data = calloc(1, sizeof(*data));
+ if (!data)
+ return NULL;
+
+ data->nr_cpus = nr_cpus;
+
+ /* one set of histograms per CPU */
+ data->cpu_data = calloc(1, sizeof(*data->cpu_data) * nr_cpus);
+ if (!data->cpu_data)
+ goto cleanup;
+
+ return data;
+
+cleanup:
+ osnoise_free_top(data);
+ return NULL;
+}
+
+/*
+ * osnoise_top_handler - this is the handler for osnoise tracer events
+ */
+static int
+osnoise_top_handler(struct trace_seq *s, struct tep_record *record,
+ struct tep_event *event, void *context)
+{
+ struct trace_instance *trace = context;
+ struct osnoise_tool *tool;
+ unsigned long long val;
+ struct osnoise_top_cpu *cpu_data;
+ struct osnoise_top_data *data;
+ int cpu = record->cpu;
+
+ tool = container_of(trace, struct osnoise_tool, trace);
+
+ data = tool->data;
+ cpu_data = &data->cpu_data[cpu];
+
+ cpu_data->sum_cycles++;
+
+ tep_get_field_val(s, event, "runtime", record, &val, 1);
+ update_sum(&cpu_data->sum_runtime, &val);
+
+ tep_get_field_val(s, event, "noise", record, &val, 1);
+ update_max(&cpu_data->max_noise, &val);
+ update_sum(&cpu_data->sum_noise, &val);
+
+ tep_get_field_val(s, event, "max_sample", record, &val, 1);
+ update_max(&cpu_data->max_sample, &val);
+
+ tep_get_field_val(s, event, "hw_count", record, &val, 1);
+ update_sum(&cpu_data->hw_count, &val);
+
+ tep_get_field_val(s, event, "nmi_count", record, &val, 1);
+ update_sum(&cpu_data->nmi_count, &val);
+
+ tep_get_field_val(s, event, "irq_count", record, &val, 1);
+ update_sum(&cpu_data->irq_count, &val);
+
+ tep_get_field_val(s, event, "softirq_count", record, &val, 1);
+ update_sum(&cpu_data->softirq_count, &val);
+
+ tep_get_field_val(s, event, "thread_count", record, &val, 1);
+ update_sum(&cpu_data->thread_count, &val);
+
+ return 0;
+}
+
+/*
+ * osnoise_top_header - print the header of the tool output
+ */
+static void osnoise_top_header(struct osnoise_tool *top)
+{
+ struct trace_seq *s = top->trace.seq;
+ char duration[26];
+
+ get_duration(top->start_time, duration, sizeof(duration));
+
+ trace_seq_printf(s, "\033[2;37;40m");
+ trace_seq_printf(s, " Operating System Noise");
+ trace_seq_printf(s, " ");
+ trace_seq_printf(s, " ");
+ trace_seq_printf(s, "\033[0;0;0m");
+ trace_seq_printf(s, "\n");
+
+ trace_seq_printf(s, "duration: %9s | time is in us\n", duration);
+
+ trace_seq_printf(s, "\033[2;30;47m");
+ trace_seq_printf(s, "CPU Period Runtime ");
+ trace_seq_printf(s, " Noise ");
+ trace_seq_printf(s, " %% CPU Aval ");
+ trace_seq_printf(s, " Max Noise Max Single ");
+ trace_seq_printf(s, " HW NMI IRQ Softirq Thread");
+ trace_seq_printf(s, "\033[0;0;0m");
+ trace_seq_printf(s, "\n");
+}
+
+/*
+ * clear_terminal - clears the output terminal
+ */
+static void clear_terminal(struct trace_seq *seq)
+{
+ if (!config_debug)
+ trace_seq_printf(seq, "\033c");
+}
+
+/*
+ * osnoise_top_print - prints the output of a given CPU
+ */
+static void osnoise_top_print(struct osnoise_tool *tool, int cpu)
+{
+ struct trace_seq *s = tool->trace.seq;
+ struct osnoise_top_cpu *cpu_data;
+ struct osnoise_top_data *data;
+ int percentage;
+ int decimal;
+
+ data = tool->data;
+ cpu_data = &data->cpu_data[cpu];
+
+ if (!cpu_data->sum_runtime)
+ return;
+
+ percentage = ((cpu_data->sum_runtime - cpu_data->sum_noise) * 10000000)
+ / cpu_data->sum_runtime;
+ decimal = percentage % 100000;
+ percentage = percentage / 100000;
+
+ trace_seq_printf(s, "%3d #%-6d %12llu ", cpu, cpu_data->sum_cycles, cpu_data->sum_runtime);
+ trace_seq_printf(s, "%12llu ", cpu_data->sum_noise);
+ trace_seq_printf(s, " %3d.%05d", percentage, decimal);
+ trace_seq_printf(s, "%12llu %12llu", cpu_data->max_noise, cpu_data->max_sample);
+
+ trace_seq_printf(s, "%12llu ", cpu_data->hw_count);
+ trace_seq_printf(s, "%12llu ", cpu_data->nmi_count);
+ trace_seq_printf(s, "%12llu ", cpu_data->irq_count);
+ trace_seq_printf(s, "%12llu ", cpu_data->softirq_count);
+ trace_seq_printf(s, "%12llu\n", cpu_data->thread_count);
+}
+
+/*
+ * osnoise_print_stats - print data for all cpus
+ */
+static void
+osnoise_print_stats(struct osnoise_top_params *params, struct osnoise_tool *top)
+{
+ struct trace_instance *trace = &top->trace;
+ static int nr_cpus = -1;
+ int i;
+
+ if (nr_cpus == -1)
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ if (!params->quiet)
+ clear_terminal(trace->seq);
+
+ osnoise_top_header(top);
+
+ for (i = 0; i < nr_cpus; i++) {
+ if (params->cpus && !params->monitored_cpus[i])
+ continue;
+ osnoise_top_print(top, i);
+ }
+
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+}
+
+/*
+ * osnoise_top_usage - prints osnoise top usage message
+ */
+void osnoise_top_usage(char *usage)
+{
+ int i;
+
+ static const char * const msg[] = {
+ " usage: rtla osnoise [top] [-h] [-q] [-p us] [-r us] [-s us] [-S us] [-T[=file]] \\",
+ " [-c cpu-list] -P priority",
+ "",
+ " -h/--help: print this menu",
+ " -p/--period us: osnoise period in us",
+ " -r/--runtime us: osnoise runtime in us",
+ " -s/--stop us: stop trace if a single sample is higher than the argument in us",
+ " -S/--stop-total us: stop trace if the total sample is higher than the argument in us",
+ " -c/--cpus cpu-list: list of cpus to run osnoise threads",
+ " -d/--duration time[s|m|h|d]: duration of the session",
+ " -t/--trace[=file]: save the stopped trace to [file|osnoise_trace.txt]",
+ " -q/--quiet print only a summary at the end",
+ " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
+ " o:prio - use SCHED_OTHER with prio",
+ " r:prio - use SCHED_RR with prio",
+ " f:prio - use SCHED_FIFO with prio",
+ " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
+ " in nanoseconds",
+ NULL,
+ };
+
+ if (usage)
+ fprintf(stderr, "%s\n", usage);
+
+ fprintf(stderr, "rtla osnoise top: a per-cpu summary of the OS noise (version %s)\n",
+ VERSION);
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+/*
+ * osnoise_top_parse_args - allocs, parse and fill the cmd line parameters
+ */
+struct osnoise_top_params *osnoise_top_parse_args(int argc, char **argv)
+{
+ struct osnoise_top_params *params;
+ int retval;
+ int c;
+
+ params = calloc(1, sizeof(*params));
+ if (!params)
+ exit(1);
+
+ while (1) {
+ static struct option long_options[] = {
+ {"cpus", required_argument, 0, 'c'},
+ {"debug", no_argument, 0, 'D'},
+ {"duration", required_argument, 0, 'd'},
+ {"help", no_argument, 0, 'h'},
+ {"period", required_argument, 0, 'p'},
+ {"priority", required_argument, 0, 'P'},
+ {"quiet", no_argument, 0, 'q'},
+ {"runtime", required_argument, 0, 'r'},
+ {"stop", required_argument, 0, 's'},
+ {"stop-total", required_argument, 0, 'S'},
+ {"trace", optional_argument, 0, 't'},
+ {0, 0, 0, 0}
+ };
+
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+
+ c = getopt_long(argc, argv, "c:d:Dhp:P:qr:s:S:t::",
+ long_options, &option_index);
+
+ /* Detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'c':
+ retval = parse_cpu_list(optarg, &params->monitored_cpus);
+ if (retval)
+ osnoise_top_usage("\nInvalid -c cpu list\n");
+ params->cpus = optarg;
+ debug_msg("-c for %s\n", params->cpus);
+ break;
+ case 'D':
+ config_debug = 1;
+ break;
+ case 'd':
+ params->duration = parse_seconds_duration(optarg);
+ if (!params->duration)
+ osnoise_top_usage("Invalid -D duration\n");
+ break;
+ case 'h':
+ case '?':
+ osnoise_top_usage(NULL);
+ break;
+ case 'p':
+ params->period = get_llong_from_str(optarg);
+ if (params->period > 10000000)
+ osnoise_top_usage("Period longer than 10 s\n");
+ break;
+ case 'P':
+ retval = parse_prio(optarg, &params->sched_param);
+ if (retval == -1)
+ osnoise_top_usage("Invalid -P priority");
+ params->set_sched = 1;
+ break;
+ case 'q':
+ params->quiet = 1;
+ break;
+ case 'r':
+ params->runtime = get_llong_from_str(optarg);
+ if (params->runtime < 100)
+ osnoise_top_usage("Runtime shorter than 100 us\n");
+ break;
+ case 's':
+ params->stop_us = get_llong_from_str(optarg);
+ break;
+ case 'S':
+ params->stop_total_us = get_llong_from_str(optarg);
+ break;
+ case 't':
+ if (optarg)
+ /* skip = */
+ params->trace_output = &optarg[1];
+ else
+ params->trace_output = "osnoise_trace.txt";
+ break;
+ default:
+ osnoise_top_usage("Invalid option");
+ }
+ }
+
+ if (geteuid()) {
+ err_msg("osnoise needs root permission\n");
+ exit(EXIT_FAILURE);
+ }
+
+ return params;
+}
+
+/*
+ * osnoise_top_apply_config - apply the top configs to the initialized tool
+ */
+static int
+osnoise_top_apply_config(struct osnoise_tool *tool, struct osnoise_top_params *params)
+{
+ int retval;
+
+ if (!params->sleep_time)
+ params->sleep_time = 1;
+
+ if (params->cpus) {
+ retval = osnoise_set_cpus(tool->context, params->cpus);
+ if (retval) {
+ err_msg("Failed to apply CPUs config\n");
+ goto out_err;
+ }
+ }
+
+ if (params->runtime || params->period) {
+ retval = osnoise_set_runtime_period(tool->context,
+ params->runtime,
+ params->period);
+ if (retval) {
+ err_msg("Failed to set runtime and/or period\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_us) {
+ retval = osnoise_set_stop_us(tool->context, params->stop_us);
+ if (retval) {
+ err_msg("Failed to set stop us\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_total_us) {
+ retval = osnoise_set_stop_total_us(tool->context, params->stop_total_us);
+ if (retval) {
+ err_msg("Failed to set stop total us\n");
+ goto out_err;
+ }
+ }
+
+ return 0;
+
+out_err:
+ return -1;
+}
+
+/*
+ * osnoise_init_top - initialize a osnoise top tool with parameters
+ */
+struct osnoise_tool *osnoise_init_top(struct osnoise_top_params *params)
+{
+ struct osnoise_tool *tool;
+ int nr_cpus;
+
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ tool = osnoise_init_tool("osnoise_top");
+ if (!tool)
+ return NULL;
+
+ tool->data = osnoise_alloc_top(nr_cpus);
+ if (!tool->data)
+ goto out_err;
+
+ tool->params = params;
+
+ tep_register_event_handler(tool->trace.tep, -1, "ftrace", "osnoise",
+ osnoise_top_handler, NULL);
+
+ return tool;
+
+out_err:
+ osnoise_free_top(tool->data);
+ osnoise_destroy_tool(tool);
+ return NULL;
+}
+
+static int stop_tracing;
+static void stop_top(int sig)
+{
+ stop_tracing = 1;
+}
+
+/*
+ * osnoise_top_set_signals - handles the signal to stop the tool
+ */
+static void osnoise_top_set_signals(struct osnoise_top_params *params)
+{
+ signal(SIGINT, stop_top);
+ if (params->duration) {
+ signal(SIGALRM, stop_top);
+ alarm(params->duration);
+ }
+}
+
+int osnoise_top_main(int argc, char **argv)
+{
+ struct osnoise_top_params *params;
+ struct trace_instance *trace;
+ struct osnoise_tool *record;
+ struct osnoise_tool *tool;
+ int return_value = 1;
+ int retval;
+
+ params = osnoise_top_parse_args(argc, argv);
+ if (!params)
+ exit(1);
+
+ tool = osnoise_init_top(params);
+ if (!tool) {
+ err_msg("Could not init osnoise top\n");
+ goto out_exit;
+ }
+
+ retval = osnoise_top_apply_config(tool, params);
+ if (retval) {
+ err_msg("Could not apply config\n");
+ goto out_top;
+ }
+
+ trace = &tool->trace;
+
+ retval = enable_osnoise(trace);
+ if (retval) {
+ err_msg("Failed to enable osnoise tracer\n");
+ goto out_top;
+ }
+
+ if (params->set_sched) {
+ retval = set_comm_sched_attr("osnoise/", &params->sched_param);
+ if (retval)
+ osnoise_top_usage("Failed to set sched parameters\n");
+ }
+
+ trace_instance_start(trace);
+
+ if (params->trace_output) {
+ record = osnoise_init_trace_tool("osnoise");
+ if (!record) {
+ err_msg("Failed to enable the trace instance\n");
+ goto out_top;
+ }
+ trace_instance_start(&record->trace);
+ }
+
+ tool->start_time = time(NULL);
+ osnoise_top_set_signals(params);
+
+ do {
+ sleep(params->sleep_time);
+
+ retval = tracefs_iterate_raw_events(trace->tep,
+ trace->inst,
+ NULL,
+ 0,
+ collect_registered_events,
+ trace);
+ if (retval < 0) {
+ err_msg("Error iterating on events\n");
+ goto out_top;
+ }
+
+ if (!params->quiet)
+ osnoise_print_stats(params, tool);
+
+ if (!tracefs_trace_is_on(trace->inst))
+ break;
+
+ } while (!stop_tracing);
+
+ osnoise_print_stats(params, tool);
+
+ return_value = 0;
+
+ if (!tracefs_trace_is_on(trace->inst)) {
+ printf("osnoise hit stop tracing\n");
+ if (params->trace_output) {
+ printf(" Saving trace to %s\n", params->trace_output);
+ save_trace_to_file(record->trace.inst, params->trace_output);
+ }
+ }
+
+out_top:
+ osnoise_free_top(tool->data);
+ osnoise_destroy_tool(tool);
+ if (params->trace_output)
+ osnoise_destroy_tool(record);
+out_exit:
+ exit(return_value);
+}
--
2.31.1


Subject: [PATCH V8 05/14] rtla/osnoise: Add the hist mode

The rtla osnoise hist tool collects all osnoise:sample_threshold
occurrence in a histogram, displaying the results in a user-friendly
way. The tool also allows many configurations of the osnoise tracer
and the collection of the tracer output.

Here is one example of the rtla osnoise hist tool output:
---------- %< ----------
[root@f34 ~]# rtla osnoise hist --bucket-size 10 --entries 100 -c 0-8 -d 1M -r 9000 -P F:1
# RTLA osnoise histogram
# Time unit is microseconds (us)
# Duration: 0 00:01:00
Index CPU-000 CPU-001 CPU-002 CPU-003 CPU-004 CPU-005 CPU-006 CPU-007 CPU-008
0 430 434 352 455 440 463 467 436 484
10 88 88 92 141 120 100 126 166 100
20 19 7 12 22 8 8 13 13 16
30 6 0 2 0 1 2 2 1 0
50 0 0 0 0 0 0 1 0 0
over: 0 0 0 0 0 0 0 0 0
count: 543 529 458 618 569 573 609 616 600
min: 0 0 0 0 0 0 0 0 0
avg: 0 0 0 0 0 0 0 0 0
max: 30 20 30 20 30 30 50 30 20
---------- >% ----------

Running
- rtla osnoise hist --help

provides information about the available options.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/src/osnoise.c | 6 +-
tools/tracing/rtla/src/osnoise.h | 1 +
tools/tracing/rtla/src/osnoise_hist.c | 799 ++++++++++++++++++++++++++
3 files changed, 805 insertions(+), 1 deletion(-)
create mode 100644 tools/tracing/rtla/src/osnoise_hist.c

diff --git a/tools/tracing/rtla/src/osnoise.c b/tools/tracing/rtla/src/osnoise.c
index 7ef686dddc09..d8bde8e45710 100644
--- a/tools/tracing/rtla/src/osnoise.c
+++ b/tools/tracing/rtla/src/osnoise.c
@@ -970,7 +970,8 @@ static void osnoise_usage(void)
" usage: [rtla] osnoise [MODE] ...",
"",
" modes:",
- " top - prints the summary from osnoise tracer",
+ " top - prints the summary from osnoise tracer",
+ " hist - prints a histogram of osnoise samples",
"",
"if no MODE is given, the top mode is called, passing the arguments",
NULL,
@@ -1005,6 +1006,9 @@ int osnoise_main(int argc, char *argv[])
} else if (strcmp(argv[1], "top") == 0) {
osnoise_top_main(argc-1, &argv[1]);
exit(0);
+ } else if (strcmp(argv[1], "hist") == 0) {
+ osnoise_hist_main(argc-1, &argv[1]);
+ exit(0);
}

usage:
diff --git a/tools/tracing/rtla/src/osnoise.h b/tools/tracing/rtla/src/osnoise.h
index e3e8f8359d99..f6c9fe05c744 100644
--- a/tools/tracing/rtla/src/osnoise.h
+++ b/tools/tracing/rtla/src/osnoise.h
@@ -91,5 +91,6 @@ void osnoise_destroy_tool(struct osnoise_tool *top);
struct osnoise_tool *osnoise_init_tool(char *tool_name);
struct osnoise_tool *osnoise_init_trace_tool(char *tracer);

+int osnoise_hist_main(int argc, char *argv[]);
int osnoise_top_main(int argc, char **argv);
int osnoise_main(int argc, char **argv);
diff --git a/tools/tracing/rtla/src/osnoise_hist.c b/tools/tracing/rtla/src/osnoise_hist.c
new file mode 100644
index 000000000000..7dadbbbaf496
--- /dev/null
+++ b/tools/tracing/rtla/src/osnoise_hist.c
@@ -0,0 +1,799 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "utils.h"
+#include "osnoise.h"
+
+struct osnoise_hist_params {
+ char *cpus;
+ char *monitored_cpus;
+ char *trace_output;
+ unsigned long long runtime;
+ unsigned long long period;
+ long long stop_us;
+ long long stop_total_us;
+ int sleep_time;
+ int duration;
+ int set_sched;
+ int output_divisor;
+ struct sched_attr sched_param;
+
+ char no_header;
+ char no_summary;
+ char no_index;
+ char with_zeros;
+ int bucket_size;
+ int entries;
+};
+
+struct osnoise_hist_cpu {
+ int *samples;
+ int count;
+
+ unsigned long long min_sample;
+ unsigned long long sum_sample;
+ unsigned long long max_sample;
+
+};
+
+struct osnoise_hist_data {
+ struct tracefs_hist *trace_hist;
+ struct osnoise_hist_cpu *hist;
+ int entries;
+ int bucket_size;
+ int nr_cpus;
+};
+
+/*
+ * osnoise_free_histogram - free runtime data
+ */
+static void
+osnoise_free_histogram(struct osnoise_hist_data *data)
+{
+ int cpu;
+
+ /* one histogram for IRQ and one for thread, per CPU */
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (data->hist[cpu].samples)
+ free(data->hist[cpu].samples);
+ }
+
+ /* one set of histograms per CPU */
+ if (data->hist)
+ free(data->hist);
+
+ free(data);
+}
+
+/*
+ * osnoise_alloc_histogram - alloc runtime data
+ */
+static struct osnoise_hist_data
+*osnoise_alloc_histogram(int nr_cpus, int entries, int bucket_size)
+{
+ struct osnoise_hist_data *data;
+ int cpu;
+
+ data = calloc(1, sizeof(*data));
+ if (!data)
+ return NULL;
+
+ data->entries = entries;
+ data->bucket_size = bucket_size;
+ data->nr_cpus = nr_cpus;
+
+ data->hist = calloc(1, sizeof(*data->hist) * nr_cpus);
+ if (!data->hist)
+ goto cleanup;
+
+ for (cpu = 0; cpu < nr_cpus; cpu++) {
+ data->hist[cpu].samples = calloc(1, sizeof(*data->hist->samples) * (entries + 1));
+ if (!data->hist[cpu].samples)
+ goto cleanup;
+ }
+
+ /* set the min to max */
+ for (cpu = 0; cpu < nr_cpus; cpu++)
+ data->hist[cpu].min_sample = ~0;
+
+ return data;
+
+cleanup:
+ osnoise_free_histogram(data);
+ return NULL;
+}
+
+static void osnoise_hist_update_multiple(struct osnoise_tool *tool, int cpu,
+ unsigned long long duration, int count)
+{
+ struct osnoise_hist_params *params = tool->params;
+ struct osnoise_hist_data *data = tool->data;
+ int entries = data->entries;
+ int bucket;
+ int *hist;
+
+ if (params->output_divisor)
+ duration = duration / params->output_divisor;
+
+ if (data->bucket_size)
+ bucket = duration / data->bucket_size;
+
+ hist = data->hist[cpu].samples;
+ data->hist[cpu].count += count;
+ update_min(&data->hist[cpu].min_sample, &duration);
+ update_sum(&data->hist[cpu].sum_sample, &duration);
+ update_max(&data->hist[cpu].max_sample, &duration);
+
+ if (bucket < entries)
+ hist[bucket] += count;
+ else
+ hist[entries] += count;
+}
+
+/*
+ * osnoise_destroy_trace_hist - disable events used to collect histogram
+ */
+static void osnoise_destroy_trace_hist(struct osnoise_tool *tool)
+{
+ struct osnoise_hist_data *data = tool->data;
+
+ tracefs_hist_pause(tool->trace.inst, data->trace_hist);
+ tracefs_hist_destroy(tool->trace.inst, data->trace_hist);
+}
+
+/*
+ * osnoise_init_trace_hist - enable events used to collect histogram
+ */
+static int osnoise_init_trace_hist(struct osnoise_tool *tool)
+{
+ struct osnoise_hist_params *params = tool->params;
+ struct osnoise_hist_data *data = tool->data;
+ int bucket_size;
+ char buff[128];
+ int retval = 0;
+
+ /*
+ * Set the size of the bucket.
+ */
+ bucket_size = params->output_divisor * params->bucket_size;
+ snprintf(buff, sizeof(buff), "duration.buckets=%d", bucket_size);
+
+ data->trace_hist = tracefs_hist_alloc(tool->trace.tep, "osnoise", "sample_threshold",
+ buff, TRACEFS_HIST_KEY_NORMAL);
+ if (!data->trace_hist)
+ return 1;
+
+ retval = tracefs_hist_add_key(data->trace_hist, "cpu", 0);
+ if (retval)
+ goto out_err;
+
+ retval = tracefs_hist_start(tool->trace.inst, data->trace_hist);
+ if (retval)
+ goto out_err;
+
+ return 0;
+
+out_err:
+ osnoise_destroy_trace_hist(tool);
+ return 1;
+}
+
+/*
+ * osnoise_read_trace_hist - parse histogram file and file osnoise histogram
+ */
+static void osnoise_read_trace_hist(struct osnoise_tool *tool)
+{
+ struct osnoise_hist_data *data = tool->data;
+ long long cpu, counter, duration;
+ char *content, *position;
+
+ tracefs_hist_pause(tool->trace.inst, data->trace_hist);
+
+ content = tracefs_event_file_read(tool->trace.inst, "osnoise",
+ "sample_threshold",
+ "hist", NULL);
+ if (!content)
+ return;
+
+ position = content;
+ while (true) {
+ position = strstr(position, "duration: ~");
+ if (!position)
+ break;
+ position += strlen("duration: ~");
+ duration = get_llong_from_str(position);
+ if (duration == -1)
+ err_msg("error reading duration from histogram\n");
+
+ position = strstr(position, "cpu:");
+ if (!position)
+ break;
+ position += strlen("cpu: ");
+ cpu = get_llong_from_str(position);
+ if (cpu == -1)
+ err_msg("error reading cpu from histogram\n");
+
+ position = strstr(position, "hitcount:");
+ if (!position)
+ break;
+ position += strlen("hitcount: ");
+ counter = get_llong_from_str(position);
+ if (counter == -1)
+ err_msg("error reading counter from histogram\n");
+
+ osnoise_hist_update_multiple(tool, cpu, duration, counter);
+ }
+ free(content);
+}
+
+/*
+ * osnoise_hist_header - print the header of the tracer to the output
+ */
+static void osnoise_hist_header(struct osnoise_tool *tool)
+{
+ struct osnoise_hist_params *params = tool->params;
+ struct osnoise_hist_data *data = tool->data;
+ struct trace_seq *s = tool->trace.seq;
+ char duration[26];
+ int cpu;
+
+ if (params->no_header)
+ return;
+
+ get_duration(tool->start_time, duration, sizeof(duration));
+ trace_seq_printf(s, "# RTLA osnoise histogram\n");
+ trace_seq_printf(s, "# Time unit is %s (%s)\n",
+ params->output_divisor == 1 ? "nanoseconds" : "microseconds",
+ params->output_divisor == 1 ? "ns" : "us");
+
+ trace_seq_printf(s, "# Duration: %s\n", duration);
+
+ if (!params->no_index)
+ trace_seq_printf(s, "Index");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ trace_seq_printf(s, " CPU-%03d", cpu);
+ }
+ trace_seq_printf(s, "\n");
+
+ trace_seq_do_printf(s);
+ trace_seq_reset(s);
+}
+
+/*
+ * osnoise_print_summary - print the summary of the hist data to the output
+ */
+static void
+osnoise_print_summary(struct osnoise_hist_params *params,
+ struct trace_instance *trace,
+ struct osnoise_hist_data *data)
+{
+ int cpu;
+
+ if (params->no_summary)
+ return;
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "count:");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ trace_seq_printf(trace->seq, "%9d ", data->hist[cpu].count);
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "min: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ trace_seq_printf(trace->seq, "%9llu ", data->hist[cpu].min_sample);
+
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "avg: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ if (data->hist[cpu].count)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].sum_sample / data->hist[cpu].count);
+ else
+ trace_seq_printf(trace->seq, " - ");
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "max: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ trace_seq_printf(trace->seq, "%9llu ", data->hist[cpu].max_sample);
+
+ }
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+}
+
+/*
+ * osnoise_print_stats - print data for all CPUs
+ */
+static void
+osnoise_print_stats(struct osnoise_hist_params *params, struct osnoise_tool *tool)
+{
+ struct osnoise_hist_data *data = tool->data;
+ struct trace_instance *trace = &tool->trace;
+ int bucket, cpu;
+ int total;
+
+ osnoise_hist_header(tool);
+
+ for (bucket = 0; bucket < data->entries; bucket++) {
+ total = 0;
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "%-6d",
+ bucket * data->bucket_size);
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ total += data->hist[cpu].samples[bucket];
+ trace_seq_printf(trace->seq, "%9d ", data->hist[cpu].samples[bucket]);
+ }
+
+ if (total == 0 && !params->with_zeros) {
+ trace_seq_reset(trace->seq);
+ continue;
+ }
+
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+ }
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "over: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].count)
+ continue;
+
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].samples[data->entries]);
+ }
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+
+ osnoise_print_summary(params, trace, data);
+}
+
+/*
+ * osnoise_hist_usage - prints osnoise hist usage message
+ */
+static void osnoise_hist_usage(char *usage)
+{
+ int i;
+
+ static const char * const msg[] = {
+ "",
+ " usage: rtla osnoise hist [-h] [-p us] [-r us] [-s us] [-S us] [-T[=file]] \\",
+ " [-c cpu-list] [-P priority] [-b N] [-e N] [--no-header] [--no-summary] \\",
+ " [--no-index] [--with-zeros]",
+ "",
+ " -h/--help: print this menu",
+ " -p/--period us: osnoise period in us",
+ " -r/--runtime us: osnoise runtime in us",
+ " -s/--stop us: stop trace if a single sample is higher than the argument in us",
+ " -S/--stop-total us: stop trace if the total sample is higher than the argument in us",
+ " -c/--cpus cpu-list: list of cpus to run osnoise threads",
+ " -d/--duration time[s|m|h|d]: duration of the session",
+ " -t/--trace[=file]: save the stopped trace to [file|osnoise_trace.txt]",
+ " -b/--bucket-size N: set the histogram bucket size (default 1)",
+ " -e/--entries N: set the number of entries of the histogram (default 256)",
+ " --no-header: do not print header",
+ " --no-summary: do not print summary",
+ " --no-index: do not print index",
+ " --with-zeros: print zero only entries",
+ " -P/--priority o:prio|r:prio|f:prio|d:runtime:period: set scheduling parameters",
+ " o:prio - use SCHED_OTHER with prio",
+ " r:prio - use SCHED_RR with prio",
+ " f:prio - use SCHED_FIFO with prio",
+ " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
+ " in nanoseconds",
+ NULL,
+ };
+
+ if (usage)
+ fprintf(stderr, "%s\n", usage);
+
+ fprintf(stderr, "rtla osnoise hist: a per-cpu histogram of the OS noise (version %s)\n",
+ VERSION);
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+/*
+ * osnoise_hist_parse_args - allocs, parse and fill the cmd line parameters
+ */
+static struct osnoise_hist_params
+*osnoise_hist_parse_args(int argc, char *argv[])
+{
+ struct osnoise_hist_params *params;
+ int retval;
+ int c;
+
+ params = calloc(1, sizeof(*params));
+ if (!params)
+ exit(1);
+
+ /* display data in microseconds */
+ params->output_divisor = 1000;
+ params->bucket_size = 1;
+ params->entries = 256;
+
+ while (1) {
+ static struct option long_options[] = {
+ {"bucket-size", required_argument, 0, 'b'},
+ {"entries", required_argument, 0, 'e'},
+ {"cpus", required_argument, 0, 'c'},
+ {"debug", no_argument, 0, 'D'},
+ {"duration", required_argument, 0, 'd'},
+ {"help", no_argument, 0, 'h'},
+ {"period", required_argument, 0, 'p'},
+ {"priority", required_argument, 0, 'P'},
+ {"runtime", required_argument, 0, 'r'},
+ {"stop", required_argument, 0, 's'},
+ {"stop-total", required_argument, 0, 'S'},
+ {"trace", optional_argument, 0, 't'},
+ {"no-header", no_argument, 0, '0'},
+ {"no-summary", no_argument, 0, '1'},
+ {"no-index", no_argument, 0, '2'},
+ {"with-zeros", no_argument, 0, '3'},
+ {0, 0, 0, 0}
+ };
+
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+
+ c = getopt_long(argc, argv, "c:b:d:e:Dhp:P:r:s:S:t::0123",
+ long_options, &option_index);
+
+ /* detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'b':
+ params->bucket_size = get_llong_from_str(optarg);
+ if ((params->bucket_size == 0) || (params->bucket_size >= 1000000))
+ osnoise_hist_usage("Bucket size needs to be > 0 and <= 1000000\n");
+ break;
+ case 'c':
+ retval = parse_cpu_list(optarg, &params->monitored_cpus);
+ if (retval)
+ osnoise_hist_usage("\nInvalid -c cpu list\n");
+ params->cpus = optarg;
+ debug_msg("-c for %s\n", params->cpus);
+ break;
+ case 'D':
+ config_debug = 1;
+ break;
+ case 'd':
+ params->duration = parse_seconds_duration(optarg);
+ if (!params->duration)
+ osnoise_hist_usage("Invalid -D duration\n");
+ break;
+ case 'e':
+ params->entries = get_llong_from_str(optarg);
+ if ((params->entries < 10) || (params->entries > 9999999))
+ osnoise_hist_usage("Entries must be > 10 and < 9999999\n");
+ break;
+ case 'h':
+ case '?':
+ osnoise_hist_usage(NULL);
+ break;
+ case 'p':
+ params->period = get_llong_from_str(optarg);
+ if (params->period > 10000000)
+ osnoise_hist_usage("Period longer than 10 s\n");
+ break;
+ case 'P':
+ retval = parse_prio(optarg, &params->sched_param);
+ if (retval == -1)
+ osnoise_hist_usage("Invalid -P priority");
+ params->set_sched = 1;
+ break;
+ case 'r':
+ params->runtime = get_llong_from_str(optarg);
+ if (params->runtime < 100)
+ osnoise_hist_usage("Runtime shorter than 100 us\n");
+ break;
+ case 's':
+ params->stop_us = get_llong_from_str(optarg);
+ break;
+ case 'S':
+ params->stop_total_us = get_llong_from_str(optarg);
+ break;
+ case 't':
+ if (optarg)
+ /* skip = */
+ params->trace_output = &optarg[1];
+ else
+ params->trace_output = "osnoise_trace.txt";
+ break;
+ case '0': /* no header */
+ params->no_header = 1;
+ break;
+ case '1': /* no summary */
+ params->no_summary = 1;
+ break;
+ case '2': /* no index */
+ params->no_index = 1;
+ break;
+ case '3': /* with zeros */
+ params->with_zeros = 1;
+ break;
+ default:
+ osnoise_hist_usage("Invalid option");
+ }
+ }
+
+ if (geteuid()) {
+ err_msg("rtla needs root permission\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (params->no_index && !params->with_zeros)
+ osnoise_hist_usage("no-index set and with-zeros not set - it does not make sense");
+
+ return params;
+}
+
+/*
+ * osnoise_hist_apply_config - apply the hist configs to the initialized tool
+ */
+static int
+osnoise_hist_apply_config(struct osnoise_tool *tool, struct osnoise_hist_params *params)
+{
+ int retval;
+
+ if (!params->sleep_time)
+ params->sleep_time = 1;
+
+ if (params->cpus) {
+ retval = osnoise_set_cpus(tool->context, params->cpus);
+ if (retval) {
+ err_msg("Failed to apply CPUs config\n");
+ goto out_err;
+ }
+ }
+
+ if (params->runtime || params->period) {
+ retval = osnoise_set_runtime_period(tool->context,
+ params->runtime,
+ params->period);
+ if (retval) {
+ err_msg("Failed to set runtime and/or period\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_us) {
+ retval = osnoise_set_stop_us(tool->context, params->stop_us);
+ if (retval) {
+ err_msg("Failed to set stop us\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_total_us) {
+ retval = osnoise_set_stop_total_us(tool->context, params->stop_total_us);
+ if (retval) {
+ err_msg("Failed to set stop total us\n");
+ goto out_err;
+ }
+ }
+
+ return 0;
+
+out_err:
+ return -1;
+}
+
+/*
+ * osnoise_init_hist - initialize a osnoise hist tool with parameters
+ */
+static struct osnoise_tool
+*osnoise_init_hist(struct osnoise_hist_params *params)
+{
+ struct osnoise_tool *tool;
+ int nr_cpus;
+
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ tool = osnoise_init_tool("osnoise_hist");
+ if (!tool)
+ return NULL;
+
+ tool->data = osnoise_alloc_histogram(nr_cpus, params->entries, params->bucket_size);
+ if (!tool->data)
+ goto out_err;
+
+ tool->params = params;
+
+ return tool;
+
+out_err:
+ osnoise_destroy_tool(tool);
+ return NULL;
+}
+
+static int stop_tracing;
+static void stop_hist(int sig)
+{
+ stop_tracing = 1;
+}
+
+/*
+ * osnoise_hist_set_signals - handles the signal to stop the tool
+ */
+static void
+osnoise_hist_set_signals(struct osnoise_hist_params *params)
+{
+ signal(SIGINT, stop_hist);
+ if (params->duration) {
+ signal(SIGALRM, stop_hist);
+ alarm(params->duration);
+ }
+}
+
+int osnoise_hist_main(int argc, char *argv[])
+{
+ struct osnoise_hist_params *params;
+ struct trace_instance *trace;
+ struct osnoise_tool *record;
+ struct osnoise_tool *tool;
+ int return_value = 1;
+ int retval;
+
+ params = osnoise_hist_parse_args(argc, argv);
+ if (!params)
+ exit(1);
+
+ tool = osnoise_init_hist(params);
+ if (!tool) {
+ err_msg("Could not init osnoise hist\n");
+ goto out_exit;
+ }
+
+ retval = osnoise_hist_apply_config(tool, params);
+ if (retval) {
+ err_msg("Could not apply config\n");
+ goto out_destroy;
+ }
+
+ trace = &tool->trace;
+
+ retval = enable_osnoise(trace);
+ if (retval) {
+ err_msg("Failed to enable osnoise tracer\n");
+ goto out_destroy;
+ }
+
+ retval = osnoise_init_trace_hist(tool);
+ if (retval)
+ goto out_destroy;
+
+ if (params->set_sched) {
+ retval = set_comm_sched_attr("osnoise/", &params->sched_param);
+ if (retval)
+ osnoise_hist_usage("Failed to set sched parameters\n");
+ }
+
+ trace_instance_start(trace);
+
+ if (params->trace_output) {
+ record = osnoise_init_trace_tool("osnoise");
+ if (!record) {
+ err_msg("Failed to enable the trace instance\n");
+ goto out_hist;
+ }
+ trace_instance_start(&record->trace);
+ }
+
+ tool->start_time = time(NULL);
+ osnoise_hist_set_signals(params);
+
+ while (!stop_tracing) {
+ sleep(params->sleep_time);
+
+ retval = tracefs_iterate_raw_events(trace->tep,
+ trace->inst,
+ NULL,
+ 0,
+ collect_registered_events,
+ trace);
+ if (retval < 0) {
+ err_msg("Error iterating on events\n");
+ goto out_hist;
+ }
+
+ if (!tracefs_trace_is_on(trace->inst))
+ break;
+ };
+
+ osnoise_read_trace_hist(tool);
+
+ osnoise_print_stats(params, tool);
+
+ return_value = 0;
+
+ if (!tracefs_trace_is_on(trace->inst)) {
+ printf("rtla timelat hit stop tracing\n");
+ if (params->trace_output) {
+ printf(" Saving trace to %s\n", params->trace_output);
+ save_trace_to_file(record->trace.inst, params->trace_output);
+ }
+ }
+
+out_hist:
+ osnoise_free_histogram(tool->data);
+out_destroy:
+ osnoise_destroy_tool(tool);
+ if (params->trace_output)
+ osnoise_destroy_tool(record);
+ free(params);
+out_exit:
+ exit(return_value);
+}
--
2.31.1


Subject: [PATCH V8 06/14] rtla: Add timerlat tool and timelart top mode

The rtla timerlat tool is an interface for the timerlat tracer.
The timerlat tracer dispatches a kernel thread per-cpu. These threads set a
periodic timer to wake themselves up and go back to sleep. After the
wakeup, they collect and generate useful information for the debugging of
operating system timer latency.

The timerlat tracer outputs information in two ways. It periodically
prints the timer latency at the timer IRQ handler and the Thread handler.
It also provides information for each noise via the osnoise tracepoints.

The rtla timerlat top mode displays a summary of the periodic output from
the timerlat tracer.

Here is one example of the rtla timerlat tool output:
---------- %< ----------
[root@alien ~]# rtla timerlat top -c 0-3 -d 1m
Timer Latency
0 00:01:00 | IRQ Timer Latency (us) | Thread Timer Latency (us)
CPU COUNT | cur min avg max | cur min avg max
0 #60001 | 0 0 0 3 | 1 1 1 6
1 #60001 | 0 0 0 3 | 2 1 1 5
2 #60001 | 0 0 1 6 | 1 1 2 7
3 #60001 | 0 0 0 7 | 1 1 1 11
---------- >% ----------

Running:
# rtla timerlat --help
# rtla timerlat top --help
provides information about the available options.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/Makefile | 2 +
tools/tracing/rtla/src/rtla.c | 5 +
tools/tracing/rtla/src/timerlat.c | 68 +++
tools/tracing/rtla/src/timerlat.h | 4 +
tools/tracing/rtla/src/timerlat_top.c | 615 ++++++++++++++++++++++++++
5 files changed, 694 insertions(+)
create mode 100644 tools/tracing/rtla/src/timerlat.c
create mode 100644 tools/tracing/rtla/src/timerlat.h
create mode 100644 tools/tracing/rtla/src/timerlat_top.c

diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
index ba6f327e815a..f254cfbe4fa3 100644
--- a/tools/tracing/rtla/Makefile
+++ b/tools/tracing/rtla/Makefile
@@ -62,6 +62,8 @@ install:
$(STRIP) $(DESTDIR)$(BINDIR)/rtla
@test ! -f $(DESTDIR)$(BINDIR)/osnoise || rm $(DESTDIR)$(BINDIR)/osnoise
ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/osnoise
+ @test ! -f $(DESTDIR)$(BINDIR)/timerlat || rm $(DESTDIR)$(BINDIR)/timerlat
+ ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/timerlat

.PHONY: clean tarball
clean:
diff --git a/tools/tracing/rtla/src/rtla.c b/tools/tracing/rtla/src/rtla.c
index 669b9750b3b3..09bd21b8af81 100644
--- a/tools/tracing/rtla/src/rtla.c
+++ b/tools/tracing/rtla/src/rtla.c
@@ -9,6 +9,7 @@
#include <stdio.h>

#include "osnoise.h"
+#include "timerlat.h"

/*
* rtla_usage - print rtla usage
@@ -25,6 +26,7 @@ static void rtla_usage(void)
"",
" commands:",
" osnoise - gives information about the operating system noise (osnoise)",
+ " timerlat - measures the timer irq and thread latency",
"",
NULL,
};
@@ -45,6 +47,9 @@ int run_command(int argc, char **argv, int start_position)
if (strcmp(argv[start_position], "osnoise") == 0) {
osnoise_main(argc-start_position, &argv[start_position]);
goto ran;
+ } else if (strcmp(argv[start_position], "timerlat") == 0) {
+ timerlat_main(argc-start_position, &argv[start_position]);
+ goto ran;
}

return 0;
diff --git a/tools/tracing/rtla/src/timerlat.c b/tools/tracing/rtla/src/timerlat.c
new file mode 100644
index 000000000000..29a51c01b084
--- /dev/null
+++ b/tools/tracing/rtla/src/timerlat.c
@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#include "timerlat.h"
+
+static void timerlat_usage(void)
+{
+ int i;
+
+ static const char * const msg[] = {
+ "",
+ "timerlat version " VERSION,
+ "",
+ " usage: [rtla] timerlat [MODE] ...",
+ "",
+ " modes:",
+ " top - prints the summary from timerlat tracer",
+ "",
+ "if no MODE is given, the top mode is called, passing the arguments",
+ NULL,
+ };
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+int timerlat_main(int argc, char *argv[])
+{
+ if (argc == 0)
+ goto usage;
+
+ /*
+ * if timerlat was called without any argument, run the
+ * default cmdline.
+ */
+ if (argc == 1) {
+ timerlat_top_main(argc, argv);
+ exit(0);
+ }
+
+ if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
+ timerlat_usage();
+ exit(0);
+ } else if (strncmp(argv[1], "-", 1) == 0) {
+ /* the user skipped the tool, call the default one */
+ timerlat_top_main(argc, argv);
+ exit(0);
+ } else if (strcmp(argv[1], "top") == 0) {
+ timerlat_top_main(argc-1, &argv[1]);
+ exit(0);
+ }
+
+usage:
+ timerlat_usage();
+ exit(1);
+}
diff --git a/tools/tracing/rtla/src/timerlat.h b/tools/tracing/rtla/src/timerlat.h
new file mode 100644
index 000000000000..6f9d3925acd0
--- /dev/null
+++ b/tools/tracing/rtla/src/timerlat.h
@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
+
+int timerlat_top_main(int argc, char *argv[]);
+int timerlat_main(int argc, char *argv[]);
diff --git a/tools/tracing/rtla/src/timerlat_top.c b/tools/tracing/rtla/src/timerlat_top.c
new file mode 100644
index 000000000000..9764681ad8b1
--- /dev/null
+++ b/tools/tracing/rtla/src/timerlat_top.c
@@ -0,0 +1,615 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "utils.h"
+#include "osnoise.h"
+#include "timerlat.h"
+
+struct timerlat_top_params {
+ char *cpus;
+ char *monitored_cpus;
+ char *trace_output;
+ unsigned long long runtime;
+ long long stop_us;
+ long long stop_total_us;
+ long long timerlat_period_us;
+ long long print_stack;
+ int sleep_time;
+ int output_divisor;
+ int duration;
+ int quiet;
+ int set_sched;
+ struct sched_attr sched_param;
+};
+
+struct timerlat_top_cpu {
+ int irq_count;
+ int thread_count;
+
+ unsigned long long cur_irq;
+ unsigned long long min_irq;
+ unsigned long long sum_irq;
+ unsigned long long max_irq;
+
+ unsigned long long cur_thread;
+ unsigned long long min_thread;
+ unsigned long long sum_thread;
+ unsigned long long max_thread;
+};
+
+struct timerlat_top_data {
+ struct timerlat_top_cpu *cpu_data;
+ int nr_cpus;
+};
+
+/*
+ * timerlat_free_top - free runtime data
+ */
+static void
+timerlat_free_top(struct timerlat_top_data *data)
+{
+ free(data->cpu_data);
+ free(data);
+}
+
+/*
+ * timerlat_alloc_histogram - alloc runtime data
+ */
+static struct timerlat_top_data *timerlat_alloc_top(int nr_cpus)
+{
+ struct timerlat_top_data *data;
+ int cpu;
+
+ data = calloc(1, sizeof(*data));
+ if (!data)
+ return NULL;
+
+ data->nr_cpus = nr_cpus;
+
+ /* one set of histograms per CPU */
+ data->cpu_data = calloc(1, sizeof(*data->cpu_data) * nr_cpus);
+ if (!data->cpu_data)
+ goto cleanup;
+
+ /* set the min to max */
+ for (cpu = 0; cpu < nr_cpus; cpu++) {
+ data->cpu_data[cpu].min_irq = ~0;
+ data->cpu_data[cpu].min_thread = ~0;
+ }
+
+ return data;
+
+cleanup:
+ timerlat_free_top(data);
+ return NULL;
+}
+
+/*
+ * timerlat_hist_update - record a new timerlat occurent on cpu, updating data
+ */
+static void
+timerlat_top_update(struct osnoise_tool *tool, int cpu,
+ unsigned long long thread,
+ unsigned long long latency)
+{
+ struct timerlat_top_data *data = tool->data;
+ struct timerlat_top_cpu *cpu_data = &data->cpu_data[cpu];
+
+ if (!thread) {
+ cpu_data->irq_count++;
+ cpu_data->cur_irq = latency;
+ update_min(&cpu_data->min_irq, &latency);
+ update_sum(&cpu_data->sum_irq, &latency);
+ update_max(&cpu_data->max_irq, &latency);
+ } else {
+ cpu_data->thread_count++;
+ cpu_data->cur_thread = latency;
+ update_min(&cpu_data->min_thread, &latency);
+ update_sum(&cpu_data->sum_thread, &latency);
+ update_max(&cpu_data->max_thread, &latency);
+ }
+}
+
+/*
+ * timerlat_top_handler - this is the handler for timerlat tracer events
+ */
+static int
+timerlat_top_handler(struct trace_seq *s, struct tep_record *record,
+ struct tep_event *event, void *context)
+{
+ struct trace_instance *trace = context;
+ unsigned long long latency, thread;
+ struct osnoise_tool *top;
+ int cpu = record->cpu;
+
+ top = container_of(trace, struct osnoise_tool, trace);
+
+ tep_get_field_val(s, event, "context", record, &thread, 1);
+ tep_get_field_val(s, event, "timer_latency", record, &latency, 1);
+
+ timerlat_top_update(top, cpu, thread, latency);
+
+ return 0;
+}
+
+/*
+ * timerlat_top_header - print the header of the tool output
+ */
+static void timerlat_top_header(struct osnoise_tool *top)
+{
+ struct timerlat_top_params *params = top->params;
+ struct trace_seq *s = top->trace.seq;
+ char duration[26];
+
+ get_duration(top->start_time, duration, sizeof(duration));
+
+ trace_seq_printf(s, "\033[2;37;40m");
+ trace_seq_printf(s, " Timer Latency ");
+ trace_seq_printf(s, "\033[0;0;0m");
+ trace_seq_printf(s, "\n");
+
+ trace_seq_printf(s, "%-6s | IRQ Timer Latency (%s) | Thread Timer Latency (%s)\n", duration,
+ params->output_divisor == 1 ? "ns" : "us",
+ params->output_divisor == 1 ? "ns" : "us");
+
+ trace_seq_printf(s, "\033[2;30;47m");
+ trace_seq_printf(s, "CPU COUNT | cur min avg max | cur min avg max");
+ trace_seq_printf(s, "\033[0;0;0m");
+ trace_seq_printf(s, "\n");
+}
+
+/*
+ * timerlat_top_print - prints the output of a given CPU
+ */
+static void timerlat_top_print(struct osnoise_tool *top, int cpu)
+{
+
+ struct timerlat_top_params *params = top->params;
+ struct timerlat_top_data *data = top->data;
+ struct timerlat_top_cpu *cpu_data = &data->cpu_data[cpu];
+ int divisor = params->output_divisor;
+ struct trace_seq *s = top->trace.seq;
+
+ if (divisor == 0)
+ return;
+
+ /*
+ * Skip if no data is available: is this cpu offline?
+ */
+ if (!cpu_data->irq_count && !cpu_data->thread_count)
+ return;
+
+ /*
+ * Unless trace is being lost, IRQ counter is always the max.
+ */
+ trace_seq_printf(s, "%3d #%-9d |", cpu, cpu_data->irq_count);
+
+ if (!cpu_data->irq_count) {
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " - |");
+ } else {
+ trace_seq_printf(s, "%9llu ", cpu_data->cur_irq / params->output_divisor);
+ trace_seq_printf(s, "%9llu ", cpu_data->min_irq / params->output_divisor);
+ trace_seq_printf(s, "%9llu ", (cpu_data->sum_irq / cpu_data->irq_count) / divisor);
+ trace_seq_printf(s, "%9llu |", cpu_data->max_irq / divisor);
+ }
+
+ if (!cpu_data->thread_count) {
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " - ");
+ trace_seq_printf(s, " -\n");
+ } else {
+ trace_seq_printf(s, "%9llu ", cpu_data->cur_thread / divisor);
+ trace_seq_printf(s, "%9llu ", cpu_data->min_thread / divisor);
+ trace_seq_printf(s, "%9llu ",
+ (cpu_data->sum_thread / cpu_data->thread_count) / divisor);
+ trace_seq_printf(s, "%9llu\n", cpu_data->max_thread / divisor);
+ }
+}
+
+/*
+ * clear_terminal - clears the output terminal
+ */
+static void clear_terminal(struct trace_seq *seq)
+{
+ if (!config_debug)
+ trace_seq_printf(seq, "\033c");
+}
+
+/*
+ * timerlat_print_stats - print data for all cpus
+ */
+static void
+timerlat_print_stats(struct timerlat_top_params *params, struct osnoise_tool *top)
+{
+ struct trace_instance *trace = &top->trace;
+ static int nr_cpus = -1;
+ int i;
+
+ if (nr_cpus == -1)
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ if (!params->quiet)
+ clear_terminal(trace->seq);
+
+ timerlat_top_header(top);
+
+ for (i = 0; i < nr_cpus; i++) {
+ if (params->cpus && !params->monitored_cpus[i])
+ continue;
+ timerlat_top_print(top, i);
+ }
+
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+}
+
+/*
+ * timerlat_top_usage - prints timerlat top usage message
+ */
+static void timerlat_top_usage(char *usage)
+{
+ int i;
+
+ static const char *const msg[] = {
+ "",
+ " usage: rtla timerlat [top] [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
+ " [-c cpu-list] [-P priority]",
+ "",
+ " -h/--help: print this menu",
+ " -p/--period us: timerlat period in us",
+ " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
+ " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
+ " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
+ " -c/--cpus cpus: run the tracer only on the given cpus -d/--duration time[m|h|d]: duration of the session in seconds",
+ " -t/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
+ " -n/--nano: display data in nanoseconds",
+ " -q/--quiet print only a summary at the end",
+ " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
+ " o:prio - use SCHED_OTHER with prio",
+ " r:prio - use SCHED_RR with prio",
+ " f:prio - use SCHED_FIFO with prio",
+ " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
+ " in nanoseconds",
+ NULL,
+ };
+
+ if (usage)
+ fprintf(stderr, "%s\n", usage);
+
+ fprintf(stderr, "rtla timerlat top: a per-cpu summary of the timer latency (version %s)\n",
+ VERSION);
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+/*
+ * timerlat_top_parse_args - allocs, parse and fill the cmd line parameters
+ */
+static struct timerlat_top_params
+*timerlat_top_parse_args(int argc, char **argv)
+{
+ struct timerlat_top_params *params;
+ int retval;
+ int c;
+
+ params = calloc(1, sizeof(*params));
+ if (!params)
+ exit(1);
+
+ /* display data in microseconds */
+ params->output_divisor = 1000;
+
+ while (1) {
+ static struct option long_options[] = {
+ {"cpus", required_argument, 0, 'c'},
+ {"debug", no_argument, 0, 'D'},
+ {"duration", required_argument, 0, 'd'},
+ {"help", no_argument, 0, 'h'},
+ {"irq", required_argument, 0, 'i'},
+ {"nano", no_argument, 0, 'n'},
+ {"period", required_argument, 0, 'p'},
+ {"priority", required_argument, 0, 'P'},
+ {"quiet", no_argument, 0, 'q'},
+ {"stack", required_argument, 0, 's'},
+ {"thread", required_argument, 0, 'T'},
+ {"trace", optional_argument, 0, 't'},
+ {0, 0, 0, 0}
+ };
+
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+
+ c = getopt_long(argc, argv, "c:d:Dhi:np:P:qs:t::T:",
+ long_options, &option_index);
+
+ /* detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'c':
+ retval = parse_cpu_list(optarg, &params->monitored_cpus);
+ if (retval)
+ timerlat_top_usage("\nInvalid -c cpu list\n");
+ params->cpus = optarg;
+ debug_msg("-c for %s\n", params->cpus);
+ break;
+ case 'D':
+ config_debug = 1;
+ break;
+ case 'd':
+ params->duration = parse_seconds_duration(optarg);
+ if (!params->duration)
+ timerlat_top_usage("Invalid -D duration\n");
+ break;
+ case 'h':
+ case '?':
+ timerlat_top_usage(NULL);
+ break;
+ case 'i':
+ params->stop_us = get_llong_from_str(optarg);
+ break;
+ case 'n':
+ params->output_divisor = 1;
+ break;
+ case 'p':
+ params->timerlat_period_us = get_llong_from_str(optarg);
+ if (params->timerlat_period_us > 1000000)
+ timerlat_top_usage("Period longer than 1 s\n");
+ break;
+ case 'P':
+ retval = parse_prio(optarg, &params->sched_param);
+ if (retval == -1)
+ timerlat_top_usage("Invalid -P priority");
+ params->set_sched = 1;
+ break;
+ case 'q':
+ params->quiet = 1;
+ break;
+ case 's':
+ params->print_stack = get_llong_from_str(optarg);
+ break;
+ case 'T':
+ params->stop_total_us = get_llong_from_str(optarg);
+ break;
+ case 't':
+ if (optarg)
+ /* skip = */
+ params->trace_output = &optarg[1];
+ else
+ params->trace_output = "timerlat_trace.txt";
+ break;
+ default:
+ timerlat_top_usage("Invalid option");
+ }
+ }
+
+ if (geteuid()) {
+ err_msg("rtla needs root permission\n");
+ exit(EXIT_FAILURE);
+ }
+
+ return params;
+}
+
+/*
+ * timerlat_top_apply_config - apply the top configs to the initialized tool
+ */
+static int
+timerlat_top_apply_config(struct osnoise_tool *top, struct timerlat_top_params *params)
+{
+ int retval;
+
+ if (!params->sleep_time)
+ params->sleep_time = 1;
+
+ if (params->cpus) {
+ retval = osnoise_set_cpus(top->context, params->cpus);
+ if (retval) {
+ err_msg("Failed to apply CPUs config\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_us) {
+ retval = osnoise_set_stop_us(top->context, params->stop_us);
+ if (retval) {
+ err_msg("Failed to set stop us\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_total_us) {
+ retval = osnoise_set_stop_total_us(top->context, params->stop_total_us);
+ if (retval) {
+ err_msg("Failed to set stop total us\n");
+ goto out_err;
+ }
+ }
+
+
+ if (params->timerlat_period_us) {
+ retval = osnoise_set_timerlat_period_us(top->context, params->timerlat_period_us);
+ if (retval) {
+ err_msg("Failed to set timerlat period\n");
+ goto out_err;
+ }
+ }
+
+
+ if (params->print_stack) {
+ retval = osnoise_set_print_stack(top->context, params->print_stack);
+ if (retval) {
+ err_msg("Failed to set print stack\n");
+ goto out_err;
+ }
+ }
+
+ return 0;
+
+out_err:
+ return -1;
+}
+
+/*
+ * timerlat_init_top - initialize a timerlat top tool with parameters
+ */
+static struct osnoise_tool
+*timerlat_init_top(struct timerlat_top_params *params)
+{
+ struct osnoise_tool *top;
+ int nr_cpus;
+
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ top = osnoise_init_tool("timerlat_top");
+ if (!top)
+ return NULL;
+
+ top->data = timerlat_alloc_top(nr_cpus);
+ if (!top->data)
+ goto out_err;
+
+ top->params = params;
+
+ tep_register_event_handler(top->trace.tep, -1, "ftrace", "timerlat",
+ timerlat_top_handler, top);
+
+ return top;
+
+out_err:
+ osnoise_destroy_tool(top);
+ return NULL;
+}
+
+static int stop_tracing;
+static void stop_top(int sig)
+{
+ stop_tracing = 1;
+}
+
+/*
+ * timerlat_top_set_signals - handles the signal to stop the tool
+ */
+static void
+timerlat_top_set_signals(struct timerlat_top_params *params)
+{
+ signal(SIGINT, stop_top);
+ if (params->duration) {
+ signal(SIGALRM, stop_top);
+ alarm(params->duration);
+ }
+}
+
+int timerlat_top_main(int argc, char *argv[])
+{
+ struct timerlat_top_params *params;
+ struct trace_instance *trace;
+ struct osnoise_tool *record;
+ struct osnoise_tool *top;
+ int return_value = 1;
+ int retval;
+
+ params = timerlat_top_parse_args(argc, argv);
+ if (!params)
+ exit(1);
+
+ top = timerlat_init_top(params);
+ if (!top) {
+ err_msg("Could not init osnoise top\n");
+ goto out_exit;
+ }
+
+ retval = timerlat_top_apply_config(top, params);
+ if (retval) {
+ err_msg("Could not apply config\n");
+ goto out_top;
+ }
+
+ trace = &top->trace;
+
+ retval = enable_timerlat(trace);
+ if (retval) {
+ err_msg("Failed to enable timerlat tracer\n");
+ goto out_top;
+ }
+
+ if (params->set_sched) {
+ retval = set_comm_sched_attr("timerlat/", &params->sched_param);
+ if (retval)
+ timerlat_top_usage("Failed to set sched parameters\n");
+ }
+
+ trace_instance_start(trace);
+
+ if (params->trace_output) {
+ record = osnoise_init_trace_tool("timerlat");
+ if (!record) {
+ err_msg("Failed to enable the trace instance\n");
+ goto out_top;
+ }
+ trace_instance_start(&record->trace);
+ }
+
+ top->start_time = time(NULL);
+ timerlat_top_set_signals(params);
+
+ while (!stop_tracing) {
+ sleep(params->sleep_time);
+
+ retval = tracefs_iterate_raw_events(trace->tep,
+ trace->inst,
+ NULL,
+ 0,
+ collect_registered_events,
+ trace);
+ if (retval < 0) {
+ err_msg("Error iterating on events\n");
+ goto out_top;
+ }
+
+ if (!params->quiet)
+ timerlat_print_stats(params, top);
+
+ if (!tracefs_trace_is_on(trace->inst))
+ break;
+
+ };
+
+ timerlat_print_stats(params, top);
+
+ return_value = 0;
+
+ if (!tracefs_trace_is_on(trace->inst)) {
+ printf("rtla timelat hit stop tracing\n");
+ if (params->trace_output) {
+ printf(" Saving trace to %s\n", params->trace_output);
+ save_trace_to_file(record->trace.inst, params->trace_output);
+ }
+ }
+
+out_top:
+ timerlat_free_top(top->data);
+ osnoise_destroy_tool(top);
+ if (params->trace_output)
+ osnoise_destroy_tool(record);
+ free(params);
+out_exit:
+ exit(return_value);
+}
--
2.31.1


Subject: [PATCH V8 07/14] rtla/timerlat: Add timerlat hist mode

The rtla hist hist mode displays a histogram of each tracer event
occurrence, both for IRQ and timer latencies. The tool also allows
many configurations of the timerlat tracer and the collection of
the tracer output.

Here is one example of the rtla timerlat hist mode output:
---------- %< ----------
[root@alien ~]# rtla timerlat hist -c 0-3 -d 1M
# RTLA timerlat histogram
# Time unit is microseconds (us)
# Duration: 0 00:01:00
Index IRQ-000 Thr-000 IRQ-001 Thr-001 IRQ-002 Thr-002 IRQ-003 Thr-003
0 58572 0 59373 0 58691 0 58895 0
1 1422 57021 628 57241 1310 56160 1102 56805
2 6 2931 0 2695 0 3567 4 3031
3 1 40 0 53 0 260 0 142
4 0 7 0 5 0 6 0 17
5 0 2 0 5 0 7 0 4
6 0 0 0 2 0 1 0 1
8 0 0 0 0 0 0 0 1
over: 0 0 0 0 0 0 0 0
count: 60001 60001 60001 60001 60001 60001 60001 60001
min: 0 1 0 1 0 1 0 1
avg: 0 1 0 1 0 1 0 1
max: 3 5 1 6 1 6 2 8
---------- >% ----------

Running
- rtla timerlat hist --help
provides information about the available options.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
tools/tracing/rtla/src/timerlat.c | 6 +-
tools/tracing/rtla/src/timerlat.h | 2 +-
tools/tracing/rtla/src/timerlat_hist.c | 820 +++++++++++++++++++++++++
3 files changed, 826 insertions(+), 2 deletions(-)
create mode 100644 tools/tracing/rtla/src/timerlat_hist.c

diff --git a/tools/tracing/rtla/src/timerlat.c b/tools/tracing/rtla/src/timerlat.c
index 29a51c01b084..97abbf494fee 100644
--- a/tools/tracing/rtla/src/timerlat.c
+++ b/tools/tracing/rtla/src/timerlat.c
@@ -25,7 +25,8 @@ static void timerlat_usage(void)
" usage: [rtla] timerlat [MODE] ...",
"",
" modes:",
- " top - prints the summary from timerlat tracer",
+ " top - prints the summary from timerlat tracer",
+ " hist - prints a histogram of timer latencies",
"",
"if no MODE is given, the top mode is called, passing the arguments",
NULL,
@@ -60,6 +61,9 @@ int timerlat_main(int argc, char *argv[])
} else if (strcmp(argv[1], "top") == 0) {
timerlat_top_main(argc-1, &argv[1]);
exit(0);
+ } else if (strcmp(argv[1], "hist") == 0) {
+ timerlat_hist_main(argc-1, &argv[1]);
+ exit(0);
}

usage:
diff --git a/tools/tracing/rtla/src/timerlat.h b/tools/tracing/rtla/src/timerlat.h
index 6f9d3925acd0..88561bfd14f3 100644
--- a/tools/tracing/rtla/src/timerlat.h
+++ b/tools/tracing/rtla/src/timerlat.h
@@ -1,4 +1,4 @@
// SPDX-License-Identifier: GPL-2.0
-
+int timerlat_hist_main(int argc, char *argv[]);
int timerlat_top_main(int argc, char *argv[]);
int timerlat_main(int argc, char *argv[]);
diff --git a/tools/tracing/rtla/src/timerlat_hist.c b/tools/tracing/rtla/src/timerlat_hist.c
new file mode 100644
index 000000000000..e1660bc61caf
--- /dev/null
+++ b/tools/tracing/rtla/src/timerlat_hist.c
@@ -0,0 +1,820 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
+ */
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "utils.h"
+#include "osnoise.h"
+#include "timerlat.h"
+
+struct timerlat_hist_params {
+ char *cpus;
+ char *monitored_cpus;
+ char *trace_output;
+ unsigned long long runtime;
+ long long stop_us;
+ long long stop_total_us;
+ long long timerlat_period_us;
+ long long print_stack;
+ int sleep_time;
+ int output_divisor;
+ int duration;
+ int set_sched;
+ struct sched_attr sched_param;
+
+ char no_irq;
+ char no_thread;
+ char no_header;
+ char no_summary;
+ char no_index;
+ char with_zeros;
+ int bucket_size;
+ int entries;
+};
+
+struct timerlat_hist_cpu {
+ int *irq;
+ int *thread;
+
+ int irq_count;
+ int thread_count;
+
+ unsigned long long min_irq;
+ unsigned long long sum_irq;
+ unsigned long long max_irq;
+
+ unsigned long long min_thread;
+ unsigned long long sum_thread;
+ unsigned long long max_thread;
+};
+
+struct timerlat_hist_data {
+ struct timerlat_hist_cpu *hist;
+ int entries;
+ int bucket_size;
+ int nr_cpus;
+};
+
+/*
+ * timerlat_free_histogram - free runtime data
+ */
+static void
+timerlat_free_histogram(struct timerlat_hist_data *data)
+{
+ int cpu;
+
+ /* one histogram for IRQ and one for thread, per CPU */
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (data->hist[cpu].irq)
+ free(data->hist[cpu].irq);
+
+ if (data->hist[cpu].thread)
+ free(data->hist[cpu].thread);
+ }
+
+ /* one set of histograms per CPU */
+ if (data->hist)
+ free(data->hist);
+
+ free(data);
+}
+
+/*
+ * timerlat_alloc_histogram - alloc runtime data
+ */
+static struct timerlat_hist_data
+*timerlat_alloc_histogram(int nr_cpus, int entries, int bucket_size)
+{
+ struct timerlat_hist_data *data;
+ int cpu;
+
+ data = calloc(1, sizeof(*data));
+ if (!data)
+ return NULL;
+
+ data->entries = entries;
+ data->bucket_size = bucket_size;
+ data->nr_cpus = nr_cpus;
+
+ /* one set of histograms per CPU */
+ data->hist = calloc(1, sizeof(*data->hist) * nr_cpus);
+ if (!data->hist)
+ goto cleanup;
+
+ /* one histogram for IRQ and one for thread, per cpu */
+ for (cpu = 0; cpu < nr_cpus; cpu++) {
+ data->hist[cpu].irq = calloc(1, sizeof(*data->hist->irq) * (entries + 1));
+ if (!data->hist[cpu].irq)
+ goto cleanup;
+ data->hist[cpu].thread = calloc(1, sizeof(*data->hist->thread) * (entries + 1));
+ if (!data->hist[cpu].thread)
+ goto cleanup;
+ }
+
+ /* set the min to max */
+ for (cpu = 0; cpu < nr_cpus; cpu++) {
+ data->hist[cpu].min_irq = ~0;
+ data->hist[cpu].min_thread = ~0;
+ }
+
+ return data;
+
+cleanup:
+ timerlat_free_histogram(data);
+ return NULL;
+}
+
+/*
+ * timerlat_hist_update - record a new timerlat occurent on cpu, updating data
+ */
+static void
+timerlat_hist_update(struct osnoise_tool *tool, int cpu,
+ unsigned long long thread,
+ unsigned long long latency)
+{
+ struct timerlat_hist_params *params = tool->params;
+ struct timerlat_hist_data *data = tool->data;
+ int entries = data->entries;
+ int bucket;
+ int *hist;
+
+ if (params->output_divisor)
+ latency = latency / params->output_divisor;
+
+ if (data->bucket_size)
+ bucket = latency / data->bucket_size;
+
+ if (!thread) {
+ hist = data->hist[cpu].irq;
+ data->hist[cpu].irq_count++;
+ update_min(&data->hist[cpu].min_irq, &latency);
+ update_sum(&data->hist[cpu].sum_irq, &latency);
+ update_max(&data->hist[cpu].max_irq, &latency);
+ } else {
+ hist = data->hist[cpu].thread;
+ data->hist[cpu].thread_count++;
+ update_min(&data->hist[cpu].min_thread, &latency);
+ update_sum(&data->hist[cpu].sum_thread, &latency);
+ update_max(&data->hist[cpu].max_thread, &latency);
+ }
+
+ if (bucket < entries)
+ hist[bucket]++;
+ else
+ hist[entries]++;
+}
+
+/*
+ * timerlat_hist_handler - this is the handler for timerlat tracer events
+ */
+static int
+timerlat_hist_handler(struct trace_seq *s, struct tep_record *record,
+ struct tep_event *event, void *data)
+{
+ struct trace_instance *trace = data;
+ unsigned long long thread, latency;
+ struct osnoise_tool *tool;
+ int cpu = record->cpu;
+
+ tool = container_of(trace, struct osnoise_tool, trace);
+
+ tep_get_field_val(s, event, "context", record, &thread, 1);
+ tep_get_field_val(s, event, "timer_latency", record, &latency, 1);
+
+ timerlat_hist_update(tool, cpu, thread, latency);
+
+ return 0;
+}
+
+/*
+ * timerlat_hist_header - print the header of the tracer to the output
+ */
+static void timerlat_hist_header(struct osnoise_tool *tool)
+{
+ struct timerlat_hist_params *params = tool->params;
+ struct timerlat_hist_data *data = tool->data;
+ struct trace_seq *s = tool->trace.seq;
+ char duration[26];
+ int cpu;
+
+ if (params->no_header)
+ return;
+
+ get_duration(tool->start_time, duration, sizeof(duration));
+ trace_seq_printf(s, "# RTLA timerlat histogram\n");
+ trace_seq_printf(s, "# Time unit is %s (%s)\n",
+ params->output_divisor == 1 ? "nanoseconds" : "microseconds",
+ params->output_divisor == 1 ? "ns" : "us");
+
+ trace_seq_printf(s, "# Duration: %s\n", duration);
+
+ if (!params->no_index)
+ trace_seq_printf(s, "Index");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq)
+ trace_seq_printf(s, " IRQ-%03d", cpu);
+
+ if (!params->no_thread)
+ trace_seq_printf(s, " Thr-%03d", cpu);
+ }
+ trace_seq_printf(s, "\n");
+
+
+ trace_seq_do_printf(s);
+ trace_seq_reset(s);
+}
+
+/*
+ * timerlat_print_summary - print the summary of the hist data to the output
+ */
+static void
+timerlat_print_summary(struct timerlat_hist_params *params,
+ struct trace_instance *trace,
+ struct timerlat_hist_data *data)
+{
+ int cpu;
+
+ if (params->no_summary)
+ return;
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "count:");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq)
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].irq_count);
+
+ if (!params->no_thread)
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].thread_count);
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "min: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].min_irq);
+
+ if (!params->no_thread)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].min_thread);
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "avg: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq) {
+ if (data->hist[cpu].irq_count)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].sum_irq / data->hist[cpu].irq_count);
+ else
+ trace_seq_printf(trace->seq, " - ");
+ }
+
+ if (!params->no_thread) {
+ if (data->hist[cpu].thread_count)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].sum_thread / data->hist[cpu].thread_count);
+ else
+ trace_seq_printf(trace->seq, " - ");
+ }
+ }
+ trace_seq_printf(trace->seq, "\n");
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "max: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].max_irq);
+
+ if (!params->no_thread)
+ trace_seq_printf(trace->seq, "%9llu ",
+ data->hist[cpu].max_thread);
+ }
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+}
+
+/*
+ * timerlat_print_stats - print data for all CPUs
+ */
+static void
+timerlat_print_stats(struct timerlat_hist_params *params, struct osnoise_tool *tool)
+{
+ struct timerlat_hist_data *data = tool->data;
+ struct trace_instance *trace = &tool->trace;
+ int bucket, cpu;
+ int total;
+
+ timerlat_hist_header(tool);
+
+ for (bucket = 0; bucket < data->entries; bucket++) {
+ total = 0;
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "%-6d",
+ bucket * data->bucket_size);
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq) {
+ total += data->hist[cpu].irq[bucket];
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].irq[bucket]);
+ }
+
+ if (!params->no_thread) {
+ total += data->hist[cpu].thread[bucket];
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].thread[bucket]);
+ }
+
+ }
+
+ if (total == 0 && !params->with_zeros) {
+ trace_seq_reset(trace->seq);
+ continue;
+ }
+
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+ }
+
+ if (!params->no_index)
+ trace_seq_printf(trace->seq, "over: ");
+
+ for (cpu = 0; cpu < data->nr_cpus; cpu++) {
+ if (params->cpus && !params->monitored_cpus[cpu])
+ continue;
+
+ if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
+ continue;
+
+ if (!params->no_irq)
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].irq[data->entries]);
+
+ if (!params->no_thread)
+ trace_seq_printf(trace->seq, "%9d ",
+ data->hist[cpu].thread[data->entries]);
+ }
+ trace_seq_printf(trace->seq, "\n");
+ trace_seq_do_printf(trace->seq);
+ trace_seq_reset(trace->seq);
+
+ timerlat_print_summary(params, trace, data);
+}
+
+/*
+ * timerlat_hist_usage - prints timerlat top usage message
+ */
+static void timerlat_hist_usage(char *usage)
+{
+ int i;
+
+ char *msg[] = {
+ "",
+ " usage: [rtla] timerlat hist [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
+ " [-c cpu-list] [-P priority] [--no-irq] [--no-thread] [--no-header] [--no-summary] \\",
+ " [--no-index] [--with-zeros]",
+ "",
+ " -h/--help: print this menu",
+ " -p/--period us: timerlat period in us",
+ " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
+ " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
+ " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
+ " -c/--cpus cpus: run the tracer only on the given cpus",
+ " -d/--duration time[m|h|d]: duration of the session in seconds",
+ " -T/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
+ " -n/--nano: display data in nanoseconds",
+ " -b/--bucket-size N: set the histogram bucket size (default 1)",
+ " -e/--entries N: set the number of entries of the histogram (default 256)",
+ " --no-irq: ignore IRQ latencies",
+ " --no-thread: ignore thread latencies",
+ " --no-header: do not print header",
+ " --no-summary: do not print summary",
+ " --no-index: do not print index",
+ " --with-zeros: print zero only entries",
+ " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
+ " o:prio - use SCHED_OTHER with prio",
+ " r:prio - use SCHED_RR with prio",
+ " f:prio - use SCHED_FIFO with prio",
+ " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
+ " in nanoseconds",
+ NULL,
+ };
+
+ if (usage)
+ fprintf(stderr, "%s\n", usage);
+
+ fprintf(stderr, "rtla timerlat hist: a per-cpu histogram of the timer latency (version %s)\n",
+ VERSION);
+
+ for (i = 0; msg[i]; i++)
+ fprintf(stderr, "%s\n", msg[i]);
+ exit(1);
+}
+
+/*
+ * timerlat_hist_parse_args - allocs, parse and fill the cmd line parameters
+ */
+static struct timerlat_hist_params
+*timerlat_hist_parse_args(int argc, char *argv[])
+{
+ struct timerlat_hist_params *params;
+ int retval;
+ int c;
+
+ params = calloc(1, sizeof(*params));
+ if (!params)
+ exit(1);
+
+ /* display data in microseconds */
+ params->output_divisor = 1000;
+ params->bucket_size = 1;
+ params->entries = 256;
+
+ while (1) {
+ static struct option long_options[] = {
+ {"cpus", required_argument, 0, 'c'},
+ {"bucket-size", required_argument, 0, 'b'},
+ {"debug", no_argument, 0, 'D'},
+ {"entries", required_argument, 0, 'e'},
+ {"duration", required_argument, 0, 'd'},
+ {"help", no_argument, 0, 'h'},
+ {"irq", required_argument, 0, 'i'},
+ {"nano", no_argument, 0, 'n'},
+ {"period", required_argument, 0, 'p'},
+ {"priority", required_argument, 0, 'P'},
+ {"stack", required_argument, 0, 's'},
+ {"thread", required_argument, 0, 'T'},
+ {"trace", optional_argument, 0, 't'},
+ {"no-irq", no_argument, 0, '0'},
+ {"no-thread", no_argument, 0, '1'},
+ {"no-header", no_argument, 0, '2'},
+ {"no-summary", no_argument, 0, '3'},
+ {"no-index", no_argument, 0, '4'},
+ {"with-zeros", no_argument, 0, '5'},
+ {0, 0, 0, 0}
+ };
+
+ /* getopt_long stores the option index here. */
+ int option_index = 0;
+
+ c = getopt_long(argc, argv, "c:b:d:e:Dhi:np:P:s:t::T:012345",
+ long_options, &option_index);
+
+ /* detect the end of the options. */
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case 'c':
+ retval = parse_cpu_list(optarg, &params->monitored_cpus);
+ if (retval)
+ timerlat_hist_usage("\nInvalid -c cpu list\n");
+ params->cpus = optarg;
+ debug_msg("-c for %s\n", params->cpus);
+ break;
+ case 'b':
+ params->bucket_size = get_llong_from_str(optarg);
+ if ((params->bucket_size == 0) || (params->bucket_size >= 1000000))
+ timerlat_hist_usage("Bucket size needs to be > 0 and <= 1000000\n");
+ break;
+ case 'D':
+ config_debug = 1;
+ break;
+ case 'd':
+ params->duration = parse_seconds_duration(optarg);
+ if (!params->duration)
+ timerlat_hist_usage("Invalid -D duration\n");
+ break;
+ case 'e':
+ params->entries = get_llong_from_str(optarg);
+ if ((params->entries < 10) || (params->entries > 9999999))
+ timerlat_hist_usage("Entries must be > 10 and < 9999999\n");
+ break;
+ case 'h':
+ case '?':
+ timerlat_hist_usage(NULL);
+ break;
+ case 'i':
+ params->stop_us = get_llong_from_str(optarg);
+ break;
+ case 'n':
+ params->output_divisor = 1;
+ break;
+ case 'p':
+ params->timerlat_period_us = get_llong_from_str(optarg);
+ if (params->timerlat_period_us > 1000000)
+ timerlat_hist_usage("Period longer than 1 s\n");
+ break;
+ case 'P':
+ retval = parse_prio(optarg, &params->sched_param);
+ if (retval == -1)
+ timerlat_hist_usage("Invalid -P priority");
+ params->set_sched = 1;
+ break;
+ case 's':
+ params->print_stack = get_llong_from_str(optarg);
+ break;
+ case 'T':
+ params->stop_total_us = get_llong_from_str(optarg);
+ break;
+ case 't':
+ if (optarg)
+ /* skip = */
+ params->trace_output = &optarg[1];
+ else
+ params->trace_output = "timerlat_trace.txt";
+ break;
+ case '0': /* no irq */
+ params->no_irq = 1;
+ break;
+ case '1': /* no thread */
+ params->no_thread = 1;
+ break;
+ case '2': /* no header */
+ params->no_header = 1;
+ break;
+ case '3': /* no summary */
+ params->no_summary = 1;
+ break;
+ case '4': /* no index */
+ params->no_index = 1;
+ break;
+ case '5': /* with zeros */
+ params->with_zeros = 1;
+ break;
+ default:
+ timerlat_hist_usage("Invalid option");
+ }
+ }
+
+ if (geteuid()) {
+ err_msg("rtla needs root permission\n");
+ exit(EXIT_FAILURE);
+ }
+
+ if (params->no_irq && params->no_thread)
+ timerlat_hist_usage("no-irq and no-thread set, there is nothing to do here");
+
+ if (params->no_index && !params->with_zeros)
+ timerlat_hist_usage("no-index set with with-zeros is not set - it does not make sense");
+
+ return params;
+}
+
+/*
+ * timerlat_hist_apply_config - apply the hist configs to the initialized tool
+ */
+static int
+timerlat_hist_apply_config(struct osnoise_tool *tool, struct timerlat_hist_params *params)
+{
+ int retval;
+
+ if (!params->sleep_time)
+ params->sleep_time = 1;
+
+ if (params->cpus) {
+ retval = osnoise_set_cpus(tool->context, params->cpus);
+ if (retval) {
+ err_msg("Failed to apply CPUs config\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_us) {
+ retval = osnoise_set_stop_us(tool->context, params->stop_us);
+ if (retval) {
+ err_msg("Failed to set stop us\n");
+ goto out_err;
+ }
+ }
+
+ if (params->stop_total_us) {
+ retval = osnoise_set_stop_total_us(tool->context, params->stop_total_us);
+ if (retval) {
+ err_msg("Failed to set stop total us\n");
+ goto out_err;
+ }
+ }
+
+ if (params->timerlat_period_us) {
+ retval = osnoise_set_timerlat_period_us(tool->context, params->timerlat_period_us);
+ if (retval) {
+ err_msg("Failed to set timerlat period\n");
+ goto out_err;
+ }
+ }
+
+ if (params->print_stack) {
+ retval = osnoise_set_print_stack(tool->context, params->print_stack);
+ if (retval) {
+ err_msg("Failed to set print stack\n");
+ goto out_err;
+ }
+ }
+
+ return 0;
+
+out_err:
+ return -1;
+}
+
+/*
+ * timerlat_init_hist - initialize a timerlat hist tool with parameters
+ */
+static struct osnoise_tool
+*timerlat_init_hist(struct timerlat_hist_params *params)
+{
+ struct osnoise_tool *tool;
+ int nr_cpus;
+
+ nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
+
+ tool = osnoise_init_tool("timerlat_hist");
+ if (!tool)
+ return NULL;
+
+ tool->data = timerlat_alloc_histogram(nr_cpus, params->entries, params->bucket_size);
+ if (!tool->data)
+ goto out_err;
+
+ tool->params = params;
+
+ tep_register_event_handler(tool->trace.tep, -1, "ftrace", "timerlat",
+ timerlat_hist_handler, tool);
+
+ return tool;
+
+out_err:
+ osnoise_destroy_tool(tool);
+ return NULL;
+}
+
+static int stop_tracing;
+static void stop_hist(int sig)
+{
+ stop_tracing = 1;
+}
+
+/*
+ * timerlat_hist_set_signals - handles the signal to stop the tool
+ */
+static void
+timerlat_hist_set_signals(struct timerlat_hist_params *params)
+{
+ signal(SIGINT, stop_hist);
+ if (params->duration) {
+ signal(SIGALRM, stop_hist);
+ alarm(params->duration);
+ }
+}
+
+int timerlat_hist_main(int argc, char *argv[])
+{
+ struct timerlat_hist_params *params;
+ struct trace_instance *trace;
+ struct osnoise_tool *record;
+ struct osnoise_tool *tool;
+ int return_value = 1;
+ int retval;
+
+ params = timerlat_hist_parse_args(argc, argv);
+ if (!params)
+ exit(1);
+
+ tool = timerlat_init_hist(params);
+ if (!tool) {
+ err_msg("Could not init osnoise hist\n");
+ goto out_exit;
+ }
+
+ retval = timerlat_hist_apply_config(tool, params);
+ if (retval) {
+ err_msg("Could not apply config\n");
+ goto out_hist;
+ }
+
+ trace = &tool->trace;
+
+ retval = enable_timerlat(trace);
+ if (retval) {
+ err_msg("Failed to enable timerlat tracer\n");
+ goto out_hist;
+ }
+
+ if (params->set_sched) {
+ retval = set_comm_sched_attr("timerlat/", &params->sched_param);
+ if (retval)
+ timerlat_hist_usage("Failed to set sched parameters\n");
+ }
+
+ trace_instance_start(trace);
+
+ if (params->trace_output) {
+ record = osnoise_init_trace_tool("timerlat");
+ if (!record) {
+ err_msg("Failed to enable the trace instance\n");
+ goto out_hist;
+ }
+ trace_instance_start(&record->trace);
+ }
+
+ tool->start_time = time(NULL);
+ timerlat_hist_set_signals(params);
+
+ while (!stop_tracing) {
+ sleep(params->sleep_time);
+
+ retval = tracefs_iterate_raw_events(trace->tep,
+ trace->inst,
+ NULL,
+ 0,
+ collect_registered_events,
+ trace);
+ if (retval < 0) {
+ err_msg("Error iterating on events\n");
+ goto out_hist;
+ }
+
+ if (!tracefs_trace_is_on(trace->inst))
+ break;
+ };
+
+ timerlat_print_stats(params, tool);
+
+ return_value = 0;
+
+ if (!tracefs_trace_is_on(trace->inst)) {
+ printf("rtla timelat hit stop tracing\n");
+ if (params->trace_output) {
+ printf(" Saving trace to %s\n", params->trace_output);
+ save_trace_to_file(record->trace.inst, params->trace_output);
+ }
+ }
+
+out_hist:
+ timerlat_free_histogram(tool->data);
+ osnoise_destroy_tool(tool);
+ if (params->trace_output)
+ osnoise_destroy_tool(record);
+ free(params);
+out_exit:
+ exit(return_value);
+}
--
2.31.1


Subject: [PATCH V8 08/14] rtla: Add Documentation

Adds the basis for rtla documentation. This patch also
includes the rtla(1) man page.

As suggested by Jonathan Corbet, we are placing these man
pages at Documentation/tools/rtla, using rst format. It
is not linked to the official documentation, though.

The Makefile is based on bpftool's Documentation one.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Suggested-by: Steven Rostedt <[email protected]>
Suggested-by: Jonathan Corbet <[email protected]>
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
Documentation/tools/rtla/Makefile | 41 +++++++++++++++++
Documentation/tools/rtla/common_appendix.rst | 12 +++++
Documentation/tools/rtla/rtla.rst | 48 ++++++++++++++++++++
tools/tracing/rtla/Makefile | 30 ++++++++++--
4 files changed, 127 insertions(+), 4 deletions(-)
create mode 100644 Documentation/tools/rtla/Makefile
create mode 100644 Documentation/tools/rtla/common_appendix.rst
create mode 100644 Documentation/tools/rtla/rtla.rst

diff --git a/Documentation/tools/rtla/Makefile b/Documentation/tools/rtla/Makefile
new file mode 100644
index 000000000000..9f2b84af1a6c
--- /dev/null
+++ b/Documentation/tools/rtla/Makefile
@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: GPL-2.0-only
+# Based on bpftool's Documentation Makefile
+
+INSTALL ?= install
+RM ?= rm -f
+RMDIR ?= rmdir --ignore-fail-on-non-empty
+
+PREFIX ?= /usr/share
+MANDIR ?= $(PREFIX)/man
+MAN1DIR = $(MANDIR)/man1
+
+MAN1_RST = $(wildcard rtla*.rst)
+
+_DOC_MAN1 = $(patsubst %.rst,%.1,$(MAN1_RST))
+DOC_MAN1 = $(addprefix $(OUTPUT),$(_DOC_MAN1))
+
+RST2MAN_DEP := $(shell command -v rst2man 2>/dev/null)
+RST2MAN_OPTS += --verbose
+
+$(OUTPUT)%.1: %.rst
+ifndef RST2MAN_DEP
+ $(error "rst2man not found, but required to generate man pages")
+endif
+ rst2man $(RST2MAN_OPTS) $< > $@
+
+man1: $(DOC_MAN1)
+man: man1
+
+clean:
+ $(RM) $(DOC_MAN1)
+
+install: man
+ $(INSTALL) -d -m 755 $(DESTDIR)$(MAN1DIR)
+ $(INSTALL) -m 644 $(DOC_MAN1) $(DESTDIR)$(MAN1DIR)
+
+uninstall:
+ $(RM) $(addprefix $(DESTDIR)$(MAN1DIR)/,$(_DOC_MAN1))
+ $(RMDIR) $(DESTDIR)$(MAN1DIR)
+
+.PHONY: man man1 clean install uninstall
+.DEFAULT_GOAL := man
diff --git a/Documentation/tools/rtla/common_appendix.rst b/Documentation/tools/rtla/common_appendix.rst
new file mode 100644
index 000000000000..b494084acccd
--- /dev/null
+++ b/Documentation/tools/rtla/common_appendix.rst
@@ -0,0 +1,12 @@
+REPORTING BUGS
+==============
+Report bugs to <[email protected]>
+
+LICENSE
+=======
+**rtla** is Free Software licensed under the GNU GPLv2
+
+COPYING
+=======
+Copyright \(C) 2021 Red Hat, Inc. Free use of this software is granted under
+the terms of the GNU Public License (GPL).
diff --git a/Documentation/tools/rtla/rtla.rst b/Documentation/tools/rtla/rtla.rst
new file mode 100644
index 000000000000..fc0d233efcd5
--- /dev/null
+++ b/Documentation/tools/rtla/rtla.rst
@@ -0,0 +1,48 @@
+=========
+rtla
+=========
+--------------------------------
+Real-time Linux Analysis tool
+--------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla** *COMMAND* [*OPTIONS*]
+
+DESCRIPTION
+===========
+The **rtla** is a meta-tool that includes a set of commands that aims to
+analyze the real-time properties of Linux. But instead of testing Linux
+as a black box, **rtla** leverages kernel tracing capabilities to provide
+precise information about the properties and root causes of unexpected
+results.
+
+COMMANDS
+========
+**osnoise**
+
+ Gives information about the operating system noise (osnoise).
+
+**timerlat**
+
+ Measures the IRQ and thread timer latency.
+
+OPTIONS
+=======
+**-h**, **--help**
+
+ Display the help text.
+
+For other options, see the man page for the corresponding command.
+
+SEE ALSO
+========
+**rtla-osnoise**\(1), **rtla-timerlat**\(1)
+
+AUTHOR
+======
+Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
index f254cfbe4fa3..8b9bee124eb3 100644
--- a/tools/tracing/rtla/Makefile
+++ b/tools/tracing/rtla/Makefile
@@ -45,18 +45,28 @@ DATADIR := /usr/share
DOCDIR := $(DATADIR)/doc
MANDIR := $(DATADIR)/man
LICDIR := $(DATADIR)/licenses
+SRCTREE := $(if $(BUILD_SRC),$(BUILD_SRC),$(CURDIR))
+
+# If running from the tarball, man pages are stored in the Documentation
+# dir. If running from the kernel source, man pages are stored in
+# Documentation/tools/rtla/.
+ifneq ($(wildcard Documentation/.*),)
+DOCSRC = Documentation/
+else
+DOCSRC = $(SRCTREE)/../../../Documentation/tools/rtla/
+endif

.PHONY: all
all: rtla

-rtla: $(OBJ)
+rtla: $(OBJ) doc
$(CC) -o rtla $(LDFLAGS) $(OBJ) $(LIBS)

static: $(OBJ)
$(CC) -o rtla-static $(LDFLAGS) --static $(OBJ) $(LIBS) -lpthread -ldl

.PHONY: install
-install:
+install: doc_install
$(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)
$(INSTALL) rtla -m 755 $(DESTDIR)$(BINDIR)
$(STRIP) $(DESTDIR)$(BINDIR)/rtla
@@ -66,15 +76,27 @@ install:
ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/timerlat

.PHONY: clean tarball
-clean:
+clean: doc_clean
@test ! -f rtla || rm rtla
@test ! -f rtla-static || rm rtla-static
@test ! -f src/rtla.o || rm src/rtla.o
@test ! -f $(TARBALL) || rm -f $(TARBALL)
@rm -rf *~ $(OBJ) *.tar.$(CEXT)

-tarball: clean
+tarball: clean
rm -rf $(NAME)-$(VERSION) && mkdir $(NAME)-$(VERSION)
cp -r $(DIRS) $(FILES) $(NAME)-$(VERSION)
+ mkdir $(NAME)-$(VERSION)/Documentation/
+ cp -rp $(SRCTREE)/../../../Documentation/tools/rtla/* $(NAME)-$(VERSION)/Documentation/
tar $(TAROPTS) --exclude='*~' $(NAME)-$(VERSION)
rm -rf $(NAME)-$(VERSION)
+
+.PHONY: doc doc_clean doc_install
+doc:
+ $(MAKE) -C $(DOCSRC)
+
+doc_clean:
+ $(MAKE) -C $(DOCSRC) clean
+
+doc_install:
+ $(MAKE) -C $(DOCSRC) install
--
2.31.1


Subject: [PATCH V8 09/14] rtla: Add rtla osnoise man page

Man page for rtla osnoise command.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
.../tools/rtla/common_osnoise_description.rst | 8 +++
Documentation/tools/rtla/rtla-osnoise.rst | 59 +++++++++++++++++++
2 files changed, 67 insertions(+)
create mode 100644 Documentation/tools/rtla/common_osnoise_description.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise.rst

diff --git a/Documentation/tools/rtla/common_osnoise_description.rst b/Documentation/tools/rtla/common_osnoise_description.rst
new file mode 100644
index 000000000000..8973c5df888f
--- /dev/null
+++ b/Documentation/tools/rtla/common_osnoise_description.rst
@@ -0,0 +1,8 @@
+The **rtla osnoise** tool is an interface for the *osnoise* tracer. The
+*osnoise* tracer dispatches a kernel thread per-cpu. These threads read the
+time in a loop while with preemption, softirq and IRQs enabled, thus
+allowing all the sources of operating systme noise during its execution.
+The *osnoise*'s tracer threads take note of the delta between each time
+read, along with an interference counter of all sources of interference.
+At the end of each period, the *osnoise* tracer displays a summary of
+the results.
diff --git a/Documentation/tools/rtla/rtla-osnoise.rst b/Documentation/tools/rtla/rtla-osnoise.rst
new file mode 100644
index 000000000000..c129b206ce34
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-osnoise.rst
@@ -0,0 +1,59 @@
+===============
+rtla-osnoise
+===============
+------------------------------------------------------------------
+Measure the operating system noise
+------------------------------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla osnoise** [*MODE*] ...
+
+DESCRIPTION
+===========
+
+.. include:: common_osnoise_description.rst
+
+The *osnoise* tracer outputs information in two ways. It periodically prints
+a summary of the noise of the operating system, including the counters of
+the occurrence of the source of interference. It also provides information
+for each noise via the **osnoise:** tracepoints. The **rtla osnoise top**
+mode displays information about the periodic summary from the *osnoise* tracer.
+The **rtla osnoise hist** mode displays information about the noise using
+the **osnoise:** tracepoints. For further details, please refer to the
+respective man page.
+
+MODES
+=====
+**top**
+
+ Prints the summary from osnoise tracer.
+
+**hist**
+
+ Prints a histogram of osnoise samples.
+
+If no MODE is given, the top mode is called, passing the arguments.
+
+OPTIONS
+=======
+
+**-h**, **--help**
+
+ Display the help text.
+
+For other options, see the man page for the corresponding mode.
+
+SEE ALSO
+========
+**rtla-osnoise-top**\(1), **rtla-osnoise-hist**\(1)
+
+Osnoise tracer documentation: <https://www.kernel.org/doc/html/latest/trace/osnoise-tracer.html>
+
+AUTHOR
+======
+Written by Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
--
2.31.1


Subject: [PATCH V8 10/14] rtla: Add rtla osnoise top documentation

Man page for rtla osnoise top mode.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
Documentation/tools/rtla/common_options.rst | 24 ++++++++
.../tools/rtla/common_osnoise_options.rst | 17 ++++++
.../tools/rtla/common_top_options.rst | 3 +
Documentation/tools/rtla/rtla-osnoise-top.rst | 61 +++++++++++++++++++
4 files changed, 105 insertions(+)
create mode 100644 Documentation/tools/rtla/common_options.rst
create mode 100644 Documentation/tools/rtla/common_osnoise_options.rst
create mode 100644 Documentation/tools/rtla/common_top_options.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise-top.rst

diff --git a/Documentation/tools/rtla/common_options.rst b/Documentation/tools/rtla/common_options.rst
new file mode 100644
index 000000000000..ea6529667e7c
--- /dev/null
+++ b/Documentation/tools/rtla/common_options.rst
@@ -0,0 +1,24 @@
+**-c**, **--cpus** *cpu-list*
+
+ Set the osnoise tracer to run the sample threads in the cpu-list.
+
+**-d**, **--duration** *time[s|m|h|d]*
+
+ Set the duration of the session.
+
+**-t**, **--trace**\[*=file*]
+
+ Save the stopped trace to [*file|osnoise_trace.txt*].
+
+**-P**, **--priority** *o:prio|r:prio|f:prio|d:runtime:period*
+
+ Set scheduling parameters to the osnoise tracer threads, the format to set the priority are:
+
+ - *o:prio* - use SCHED_OTHER with *prio*;
+ - *r:prio* - use SCHED_RR with *prio*;
+ - *f:prio* - use SCHED_FIFO with *prio*;
+ - *d:runtime[us|ms|s]:period[us|ms|s]* - use SCHED_DEADLINE with *runtime* and *period* in nanoseconds.
+
+**-h**, **--help**
+
+ Print help menu.
diff --git a/Documentation/tools/rtla/common_osnoise_options.rst b/Documentation/tools/rtla/common_osnoise_options.rst
new file mode 100644
index 000000000000..d556883e4e26
--- /dev/null
+++ b/Documentation/tools/rtla/common_osnoise_options.rst
@@ -0,0 +1,17 @@
+**-p**, **--period** *us*
+
+ Set the *osnoise* tracer period in microseconds.
+
+**-r**, **--runtime** *us*
+
+ Set the *osnoise* tracer runtime in microseconds.
+
+**-s**, **--stop** *us*
+
+ Stop the trace if a single sample is higher than the argument in microseconds.
+ If **-T** is set, it will also save the trace to the output.
+
+**-S**, **--stop-total** *us*
+
+ Stop the trace if the total sample is higher than the argument in microseconds.
+ If **-T** is set, it will also save the trace to the output.
diff --git a/Documentation/tools/rtla/common_top_options.rst b/Documentation/tools/rtla/common_top_options.rst
new file mode 100644
index 000000000000..f48878938f84
--- /dev/null
+++ b/Documentation/tools/rtla/common_top_options.rst
@@ -0,0 +1,3 @@
+**-q**, **--quiet**
+
+ Print only a summary at the end of the session.
diff --git a/Documentation/tools/rtla/rtla-osnoise-top.rst b/Documentation/tools/rtla/rtla-osnoise-top.rst
new file mode 100644
index 000000000000..5d75d1394516
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-osnoise-top.rst
@@ -0,0 +1,61 @@
+===================
+rtla-osnoise-top
+===================
+-----------------------------------------------
+Display a summary of the operating system noise
+-----------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla osnoise top** [*OPTIONS*]
+
+DESCRIPTION
+===========
+.. include:: common_osnoise_description.rst
+
+**rtla osnoise top** collects the periodic summary from the *osnoise* tracer,
+including the counters of the occurrence of the interference source,
+displaying the results in a user-friendly format.
+
+The tool also allows many configurations of the *osnoise* tracer and the
+collection of the tracer output.
+
+OPTIONS
+=======
+.. include:: common_osnoise_options.rst
+
+.. include:: common_top_options.rst
+
+.. include:: common_options.rst
+
+EXAMPLE
+=======
+In the example below, the **rtla osnoise top** tool is set to run with a
+real-time priority *FIFO:1*, on CPUs *0-3*, for *900ms* at each period
+(*1s* by default). The reason for reducing the runtime is to avoid starving
+the rtla tool. The tool is also set to run for *one minute* and to display
+a summary of the report at the end of the session::
+
+ [root@f34 ~]# rtla osnoise top -P F:1 -c 0-3 -r 900000 -d 1M -q
+ Operating System Noise
+ duration: 0 00:01:00 | time is in us
+ CPU Period Runtime Noise % CPU Aval Max Noise Max Single HW NMI IRQ Softirq Thread
+ 0 #59 53100000 304896 99.42580 6978 56 549 0 53111 1590 13
+ 1 #59 53100000 338339 99.36282 8092 24 399 0 53130 1448 31
+ 2 #59 53100000 290842 99.45227 6582 39 855 0 53110 1406 12
+ 3 #59 53100000 204935 99.61405 6251 33 290 0 53156 1460 12
+
+SEE ALSO
+========
+
+**rtla-osnoise**\(1), **rtla-osnoise-hist**\(1)
+
+Osnoise tracer documentation: <https://www.kernel.org/doc/html/latest/trace/osnoise-tracer.html>
+
+AUTHOR
+======
+Written by Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
--
2.31.1


Subject: [PATCH V8 11/14] rtla: Add rtla osnoise hist documentation

Man page for rtla osnoise hist mode.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
.../tools/rtla/common_hist_options.rst | 23 +++++++
.../tools/rtla/rtla-osnoise-hist.rst | 66 +++++++++++++++++++
2 files changed, 89 insertions(+)
create mode 100644 Documentation/tools/rtla/common_hist_options.rst
create mode 100644 Documentation/tools/rtla/rtla-osnoise-hist.rst

diff --git a/Documentation/tools/rtla/common_hist_options.rst b/Documentation/tools/rtla/common_hist_options.rst
new file mode 100644
index 000000000000..0266cd08a6c9
--- /dev/null
+++ b/Documentation/tools/rtla/common_hist_options.rst
@@ -0,0 +1,23 @@
+**-b**, **--bucket-size** *N*
+
+ Set the histogram bucket size (default *1*).
+
+**-e**, **--entries** *N*
+
+ Set the number of entries of the histogram (default 256).
+
+**--no-header**
+
+ Do not print header.
+
+**--no-summary**
+
+ Do not print summary.
+
+**--no-index**
+
+ Do not print index.
+
+**--with-zeros**
+
+ Print zero only entries.
diff --git a/Documentation/tools/rtla/rtla-osnoise-hist.rst b/Documentation/tools/rtla/rtla-osnoise-hist.rst
new file mode 100644
index 000000000000..52298ddd8701
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-osnoise-hist.rst
@@ -0,0 +1,66 @@
+===================
+rtla-osnoise-hist
+===================
+------------------------------------------------------
+Display a histogram of the osnoise tracer samples
+------------------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla osnoise hist** [*OPTIONS*]
+
+DESCRIPTION
+===========
+.. include:: common_osnoise_description.rst
+
+The **rtla osnoise hist** tool collects all **osnoise:sample_threshold**
+occurrence in a histogram, displaying the results in a user-friendly way.
+The tool also allows many configurations of the *osnoise* tracer and the
+collection of the tracer output.
+
+OPTIONS
+=======
+.. include:: common_osnoise_options.rst
+
+.. include:: common_hist_options.rst
+
+.. include:: common_options.rst
+
+EXAMPLE
+=======
+In the example below, *osnoise* tracer threads are set to run with real-time
+priority *FIFO:1*, on CPUs *0-11*, for *900ms* at each period (*1s* by
+default). The reason for reducing the runtime is to avoid starving the
+**rtla** tool. The tool is also set to run for *one minute*. The output
+histogram is set to group outputs in buckets of *10us* and *25* entries::
+
+ [root@f34 ~/]# rtla osnoise hist -P F:1 -c 0-11 -r 900000 -d 1M -b 10 -e 25
+ # RTLA osnoise histogram
+ # Time unit is microseconds (us)
+ # Duration: 0 00:01:00
+ Index CPU-000 CPU-001 CPU-002 CPU-003 CPU-004 CPU-005 CPU-006 CPU-007 CPU-008 CPU-009 CPU-010 CPU-011
+ 0 42982 46287 51779 53740 52024 44817 49898 36500 50408 50128 49523 52377
+ 10 12224 8356 2912 878 2667 10155 4573 18894 4214 4836 5708 2413
+ 20 8 5 12 2 13 24 20 41 29 53 39 39
+ 30 1 1 0 0 10 3 6 19 15 31 30 38
+ 40 0 0 0 0 0 4 2 7 2 3 8 11
+ 50 0 0 0 0 0 0 0 0 0 1 1 2
+ over: 0 0 0 0 0 0 0 0 0 0 0 0
+ count: 55215 54649 54703 54620 54714 55003 54499 55461 54668 55052 55309 54880
+ min: 0 0 0 0 0 0 0 0 0 0 0 0
+ avg: 0 0 0 0 0 0 0 0 0 0 0 0
+ max: 30 30 20 20 30 40 40 40 40 50 50 50
+
+SEE ALSO
+========
+**rtla-osnoise**\(1), **rtla-osnoise-top**\(1)
+
+*osnoise* tracer documentation: <https://www.kernel.org/doc/html/latest/trace/osnoise-tracer.html>
+
+AUTHOR
+======
+Written by Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
--
2.31.1


Subject: [PATCH V8 12/14] rtla: Add rtla timerlat documentation

Man page for rtla timerlat tool.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
.../rtla/common_timerlat_description.rst | 10 ++++
Documentation/tools/rtla/rtla-timerlat.rst | 57 +++++++++++++++++++
2 files changed, 67 insertions(+)
create mode 100644 Documentation/tools/rtla/common_timerlat_description.rst
create mode 100644 Documentation/tools/rtla/rtla-timerlat.rst

diff --git a/Documentation/tools/rtla/common_timerlat_description.rst b/Documentation/tools/rtla/common_timerlat_description.rst
new file mode 100644
index 000000000000..321201cb8597
--- /dev/null
+++ b/Documentation/tools/rtla/common_timerlat_description.rst
@@ -0,0 +1,10 @@
+The **rtla timerlat** tool is an interface for the *timerlat* tracer. The
+*timerlat* tracer dispatches a kernel thread per-cpu. These threads
+set a periodic timer to wake themselves up and go back to sleep. After
+the wakeup, they collect and generate useful information for the
+debugging of operating system timer latency.
+
+The *timerlat* tracer outputs information in two ways. It periodically
+prints the timer latency at the timer *IRQ* handler and the *Thread*
+handler. It also enable the trace of the most relevant information via
+**osnoise:** tracepoints.
diff --git a/Documentation/tools/rtla/rtla-timerlat.rst b/Documentation/tools/rtla/rtla-timerlat.rst
new file mode 100644
index 000000000000..44a49e6f302b
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-timerlat.rst
@@ -0,0 +1,57 @@
+================
+rtla-timerlat
+================
+-------------------------------------------
+Measures the operating system timer latency
+-------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla timerlat** [*MODE*] ...
+
+DESCRIPTION
+===========
+
+.. include:: common_timerlat_description.rst
+
+The *timerlat* tracer outputs information in two ways. It periodically
+prints the timer latency at the timer *IRQ* handler and the *Thread* handler.
+It also provides information for each noise via the **osnoise:** tracepoints.
+The **rtla timerlat top** mode displays a summary of the periodic output
+from the *timerlat* tracer. The **rtla hist hist** mode displays a histogram
+of each tracer event occurrence. For further details, please refer to the
+respective man page.
+
+MODES
+=====
+**top**
+
+ Prints the summary from *timerlat* tracer.
+
+**hist**
+
+ Prints a histogram of timerlat samples.
+
+If no *MODE* is given, the top mode is called, passing the arguments.
+
+OPTIONS
+=======
+**-h**, **--help**
+
+ Display the help text.
+
+For other options, see the man page for the corresponding mode.
+
+SEE ALSO
+========
+**rtla-timerlat-top**\(1), **rtla-timerlat-hist**\(1)
+
+*timerlat* tracer documentation: <https://www.kernel.org/doc/html/latest/trace/timerlat-tracer.html>
+
+AUTHOR
+======
+Written by Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
--
2.31.1


Subject: [PATCH V8 13/14] rtla: Add rtla timerlat top documentation

Man page for rtla timerlat top mode.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
.../tools/rtla/common_timerlat_options.rst | 16 ++
.../tools/rtla/rtla-timerlat-top.rst | 145 ++++++++++++++++++
2 files changed, 161 insertions(+)
create mode 100644 Documentation/tools/rtla/common_timerlat_options.rst
create mode 100644 Documentation/tools/rtla/rtla-timerlat-top.rst

diff --git a/Documentation/tools/rtla/common_timerlat_options.rst b/Documentation/tools/rtla/common_timerlat_options.rst
new file mode 100644
index 000000000000..e9c1bfd55d48
--- /dev/null
+++ b/Documentation/tools/rtla/common_timerlat_options.rst
@@ -0,0 +1,16 @@
+**-p**, **--period** *us*
+
+ Set the *timerlat* tracer period in microseconds.
+
+**-i**, **--irq** *us*
+
+ Stop trace if the *IRQ* latency is higher than the argument in us.
+
+**-T**, **--thread** *us*
+
+ Stop trace if the *Thread* latency is higher than the argument in us.
+
+**-s**, **--stack** *us*
+
+ Save the stack trace at the *IRQ* if a *Thread* latency is higher than the
+ argument in us.
diff --git a/Documentation/tools/rtla/rtla-timerlat-top.rst b/Documentation/tools/rtla/rtla-timerlat-top.rst
new file mode 100644
index 000000000000..1c321de1c171
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-timerlat-top.rst
@@ -0,0 +1,145 @@
+====================
+rtla-timerlat-top
+====================
+-------------------------------------------
+Measures the operating system timer latency
+-------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla timerlat top** [*OPTIONS*] ...
+
+DESCRIPTION
+===========
+
+.. include:: common_timerlat_description.rst
+
+The **rtla timerlat top** displays a summary of the periodic output
+from the *timerlat* tracer. It also provides information for each
+operating system noise via the **osnoise:** tracepoints that can be
+seem with the option **-T**.
+
+OPTIONS
+=======
+
+.. include:: common_timerlat_options.rst
+
+.. include:: common_top_options.rst
+
+.. include:: common_options.rst
+
+EXAMPLE
+=======
+
+In the example below, the *timerlat* tracer is set to capture the stack trace at
+the IRQ handler, printing it to the buffer if the *Thread* timer latency is
+higher than *30 us*. It is also set to stop the session if a *Thread* timer
+latency higher than *30 us* is hit. Finally, it is set to save the trace
+buffer if the stop condition is hit::
+
+ [root@alien ~]# rtla timerlat top -s 30 -t 30 -T
+ Timer Latency
+ 0 00:00:59 | IRQ Timer Latency (us) | Thread Timer Latency (us)
+ CPU COUNT | cur min avg max | cur min avg max
+ 0 #58634 | 1 0 1 10 | 11 2 10 23
+ 1 #58634 | 1 0 1 9 | 12 2 9 23
+ 2 #58634 | 0 0 1 11 | 10 2 9 23
+ 3 #58634 | 1 0 1 11 | 11 2 9 24
+ 4 #58634 | 1 0 1 10 | 11 2 9 26
+ 5 #58634 | 1 0 1 8 | 10 2 9 25
+ 6 #58634 | 12 0 1 12 | 30 2 10 30 <--- CPU with spike
+ 7 #58634 | 1 0 1 9 | 11 2 9 23
+ 8 #58633 | 1 0 1 9 | 11 2 9 26
+ 9 #58633 | 1 0 1 9 | 10 2 9 26
+ 10 #58633 | 1 0 1 13 | 11 2 9 28
+ 11 #58633 | 1 0 1 13 | 12 2 9 24
+ 12 #58633 | 1 0 1 8 | 10 2 9 23
+ 13 #58633 | 1 0 1 10 | 10 2 9 22
+ 14 #58633 | 1 0 1 18 | 12 2 9 27
+ 15 #58633 | 1 0 1 10 | 11 2 9 28
+ 16 #58633 | 0 0 1 11 | 7 2 9 26
+ 17 #58633 | 1 0 1 13 | 10 2 9 24
+ 18 #58633 | 1 0 1 9 | 13 2 9 22
+ 19 #58633 | 1 0 1 10 | 11 2 9 23
+ 20 #58633 | 1 0 1 12 | 11 2 9 28
+ 21 #58633 | 1 0 1 14 | 11 2 9 24
+ 22 #58633 | 1 0 1 8 | 11 2 9 22
+ 23 #58633 | 1 0 1 10 | 11 2 9 27
+ timerlat hit stop tracing
+ saving trace to timerlat_trace.txt
+ [root@alien bristot]# tail -60 timerlat_trace.txt
+ [...]
+ timerlat/5-79755 [005] ....... 426.271226: #58634 context thread timer_latency 10823 ns
+ sh-109404 [006] dnLh213 426.271247: #58634 context irq timer_latency 12505 ns
+ sh-109404 [006] dNLh313 426.271258: irq_noise: local_timer:236 start 426.271245463 duration 12553 ns
+ sh-109404 [006] d...313 426.271263: thread_noise: sh:109404 start 426.271245853 duration 4769 ns
+ timerlat/6-79756 [006] ....... 426.271264: #58634 context thread timer_latency 30328 ns
+ timerlat/6-79756 [006] ....1.. 426.271265: <stack trace>
+ => timerlat_irq
+ => __hrtimer_run_queues
+ => hrtimer_interrupt
+ => __sysvec_apic_timer_interrupt
+ => sysvec_apic_timer_interrupt
+ => asm_sysvec_apic_timer_interrupt
+ => _raw_spin_unlock_irqrestore <---- spinlock that disabled interrupt.
+ => try_to_wake_up
+ => autoremove_wake_function
+ => __wake_up_common
+ => __wake_up_common_lock
+ => ep_poll_callback
+ => __wake_up_common
+ => __wake_up_common_lock
+ => fsnotify_add_event
+ => inotify_handle_inode_event
+ => fsnotify
+ => __fsnotify_parent
+ => __fput
+ => task_work_run
+ => exit_to_user_mode_prepare
+ => syscall_exit_to_user_mode
+ => do_syscall_64
+ => entry_SYSCALL_64_after_hwframe
+ => 0x7265000001378c
+ => 0x10000cea7
+ => 0x25a00000204a
+ => 0x12e302d00000000
+ => 0x19b51010901b6
+ => 0x283ce00726500
+ => 0x61ea308872
+ => 0x00000fe3
+ bash-109109 [007] d..h... 426.271265: #58634 context irq timer_latency 1211 ns
+ timerlat/6-79756 [006] ....... 426.271267: timerlat_main: stop tracing hit on cpu 6
+
+In the trace, it is possible the notice that the *IRQ* timer latency was
+already high, accounting *12505 ns*. The IRQ delay was caused by the
+*bash-109109* process that disabled IRQs in the wake-up path
+(*_try_to_wake_up()* function). The duration of the IRQ handler that woke
+up the timerlat thread, informed with the **osnoise:irq_noise** event, was
+also high and added more *12553 ns* to the Thread latency. Finally, the
+**osnoise:thread_noise** added by the currently running thread (including
+the scheduling overhead) added more *4769 ns*. Summing up these values,
+the *Thread* timer latency accounted for *30328 ns*.
+
+The primary reason for this high value is the wake-up path that was hit
+twice during this case: when the *bash-109109* was waking up a thread
+and then when the *timerlat* thread was awakened. This information can
+then be used as the starting point of a more fine-grained analysis.
+
+Note that **rtla timerlat** was dispatched without changing *timerlat* tracer
+threads' priority. That is generally not needed because these threads hava
+priority *FIFO:95* by default, which is a common priority used by real-time
+kernel developers to analyze scheduling delays.
+
+SEE ALSO
+--------
+**rtla-timerlat**\(1), **rtla-timerlat-hist**\(1)
+
+*timerlat* tracer documentation: <https://www.kernel.org/doc/html/latest/trace/timerlat-tracer.html>
+
+AUTHOR
+------
+Written by Daniel Bristot de Oliveira <[email protected]>
+
+.. include:: common_appendix.rst
--
2.31.1


Subject: [PATCH V8 14/14] rtla: Add rtla timerlat hist documentation

Man page for rtla timerlat hist mode.

Cc: Steven Rostedt <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Tom Zanussi <[email protected]>
Cc: Masami Hiramatsu <[email protected]>
Cc: Juri Lelli <[email protected]>
Cc: Clark Williams <[email protected]>
Cc: John Kacur <[email protected]>
Cc: Peter Zijlstra <[email protected]>
Cc: Thomas Gleixner <[email protected]>
Cc: Sebastian Andrzej Siewior <[email protected]>
Cc: Daniel Bristot de Oliveira <[email protected]>
Cc: [email protected]
Cc: [email protected]
Cc: [email protected]
Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
---
.../tools/rtla/rtla-timerlat-hist.rst | 106 ++++++++++++++++++
1 file changed, 106 insertions(+)
create mode 100644 Documentation/tools/rtla/rtla-timerlat-hist.rst

diff --git a/Documentation/tools/rtla/rtla-timerlat-hist.rst b/Documentation/tools/rtla/rtla-timerlat-hist.rst
new file mode 100644
index 000000000000..e12eae1f3301
--- /dev/null
+++ b/Documentation/tools/rtla/rtla-timerlat-hist.rst
@@ -0,0 +1,106 @@
+=====================
+rtla-timerlat-hist
+=====================
+------------------------------------------------
+Histograms of the operating system timer latency
+------------------------------------------------
+
+:Manual section: 1
+
+SYNOPSIS
+========
+**rtla timerlat hist** [*OPTIONS*] ...
+
+DESCRIPTION
+===========
+
+.. include:: common_timerlat_description.rst
+
+The **rtla timerlat hist** displays a histogram of each tracer event
+occurrence. This tool uses the periodic information, and the
+**osnoise:** tracepoints are enabled when using the **-T** option.
+
+OPTIONS
+=======
+
+.. include:: common_timerlat_options.rst
+
+.. include:: common_hist_options.rst
+
+.. include:: common_options.rst
+
+EXAMPLE
+=======
+In the example below, **rtla timerlat hist** is set to run for *10* minutes,
+in the cpus *0-4*, *skipping zero* only lines. Moreover, **rtla timerlat
+hist** will change the priority of the *timelat* threads to run under
+*SCHED_DEADLINE* priority, with a *10us* runtime every *1ms* period. The
+*1ms* period is also passed to the *timerlat* tracer::
+
+ [root@alien ~]# timerlat hist -d 10m -c 0-4 -P d:100us:1ms -p 1ms
+ # RTLA timerlat histogram
+ # Time unit is microseconds (us)
+ # Duration: 0 00:10:00
+ Index IRQ-000 Thr-000 IRQ-001 Thr-001 IRQ-002 Thr-002 IRQ-003 Thr-003 IRQ-004 Thr-004
+ 0 276489 0 206089 0 466018 0 481102 0 205546 0
+ 1 318327 35487 388149 30024 94531 48382 83082 71078 388026 55730
+ 2 3282 122584 4019 126527 28231 109012 23311 89309 4568 98739
+ 3 940 11815 837 9863 6209 16227 6895 17196 910 9780
+ 4 444 17287 424 11574 2097 38443 2169 36736 462 13476
+ 5 206 43291 255 25581 1223 101908 1304 101137 236 28913
+ 6 132 101501 96 64584 635 213774 757 215471 99 73453
+ 7 74 169347 65 124758 350 57466 441 53639 69 148573
+ 8 53 85183 31 156751 229 9052 306 9026 39 139907
+ 9 22 10387 12 42762 161 2554 225 2689 19 26192
+ 10 13 1898 8 5770 114 1247 128 1405 13 3772
+ 11 9 560 9 924 71 686 76 765 8 713
+ 12 4 256 2 360 50 411 64 474 3 278
+ 13 2 167 2 172 43 256 53 350 4 180
+ 14 1 88 1 116 15 198 42 223 0 115
+ 15 2 63 3 94 11 139 20 150 0 58
+ 16 2 37 0 56 5 78 10 102 0 39
+ 17 0 18 0 28 4 57 8 80 0 15
+ 18 0 8 0 17 2 50 6 56 0 12
+ 19 0 9 0 5 0 19 0 48 0 18
+ 20 0 4 0 8 0 11 2 27 0 4
+ 21 0 2 0 3 1 9 1 18 0 6
+ 22 0 1 0 3 1 7 0 3 0 5
+ 23 0 2 0 4 0 2 0 7 0 2
+ 24 0 2 0 2 1 3 0 3 0 5
+ 25 0 0 0 1 0 1 0 1 0 3
+ 26 0 1 0 0 0 2 0 2 0 0
+ 27 0 0 0 3 0 1 0 0 0 1
+ 28 0 0 0 3 0 0 0 1 0 0
+ 29 0 0 0 2 0 2 0 1 0 3
+ 30 0 1 0 0 0 0 0 0 0 0
+ 31 0 1 0 0 0 0 0 2 0 2
+ 32 0 0 0 1 0 2 0 0 0 0
+ 33 0 0 0 2 0 0 0 0 0 1
+ 34 0 0 0 0 0 0 0 0 0 2
+ 35 0 1 0 1 0 0 0 0 0 1
+ 36 0 1 0 0 0 1 0 1 0 0
+ 37 0 0 0 1 0 0 0 0 0 0
+ 40 0 0 0 0 0 1 0 1 0 0
+ 41 0 0 0 0 0 0 0 0 0 1
+ 42 0 0 0 0 0 0 0 0 0 1
+ 44 0 0 0 0 0 1 0 0 0 0
+ 46 0 0 0 0 0 0 0 1 0 0
+ 47 0 0 0 0 0 0 0 0 0 1
+ 50 0 0 0 0 0 0 0 0 0 1
+ 54 0 0 0 1 0 0 0 0 0 0
+ 58 0 0 0 1 0 0 0 0 0 0
+ over: 0 0 0 0 0 0 0 0 0 0
+ count: 600002 600002 600002 600002 600002 600002 600002 600002 600002 600002
+ min: 0 1 0 1 0 1 0 1 0 1
+ avg: 0 5 0 5 0 4 0 4 0 5
+ max: 16 36 15 58 24 44 21 46 13 50
+
+SEE ALSO
+========
+**rtla-timerlat**\(1), **rtla-timerlat-top**\(1)
+
+*timerlat* tracer documentation: <https://www.kernel.org/doc/html/latest/trace/timerlat-tracer.html>
+
+AUTHOR
+======
+Written by Daniel Bristot de Oliveira <[email protected]>
--
2.31.1


2021-11-30 15:37:01

by Tao Zhou

[permalink] [raw]
Subject: Re: [PATCH V8 03/14] rtla: Add osnoise tool

Hi Daniel,

On Mon, Nov 29, 2021 at 12:07:41PM +0100, Daniel Bristot de Oliveira wrote:
> +/*
> + * osnoise_restore_cpus - restore the original "osnoise/cpus"
> + *
> + * osnoise_set_cpus() saves the original data for the "osnoise/cpus"

osnoise_set_cpus() --> osnoise_restore_cpus()

> + * file. This function restore the original config it was previously
> + * modified.
> + */
> +void osnoise_restore_cpus(struct osnoise_context *context)
> +{
> + int retval;
> +
> + if (!context->orig_cpus)
> + return;
> +
> + if (!context->curr_cpus)
> + return;
> +
> + /* nothing to do? */
> + if (!strcmp(context->orig_cpus, context->curr_cpus))
> + goto out_done;
> +
> + retval = write(context->cpus_fd, context->orig_cpus, strlen(context->orig_cpus));

'strlen(context->orig_cpus) + 1' for write size;

> + if (retval < strlen(context->orig_cpus))

Same here. Check 'strlen(context->orig_cpus) + 1'

> + err_msg("could not restore original osnoise cpus\n");
> +
> +out_done:
> + free(context->curr_cpus);
> + context->curr_cpus = NULL;
> +}
> +
> +/*
> + * osnoise_get_runtime - return the original "osnoise/runtime_us" value
> + *
> + * It also saves the value to be restored.
> + */
> +unsigned long long osnoise_get_runtime(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long runtime_us;
> + char *runtime_path;
> + int retval;
> +
> + if (context->runtime_us != OSNOISE_TIME_INIT_VAL)
> + return context->runtime_us;
> +
> + if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_runtime_us;
> +
> + runtime_path = tracefs_get_tracing_file("osnoise/runtime_us");
> +
> + context->runtime_fd = open(runtime_path, O_RDWR);
> + if (context->runtime_fd < 0)
> + goto out_err;
> +
> + retval = read(context->runtime_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + runtime_us = get_llong_from_str(buffer);
> + if (runtime_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(runtime_path);
> +
> + context->orig_runtime_us = runtime_us;
> + return runtime_us;
> +
> +out_close:
> + close(context->runtime_fd);
> + context->runtime_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(runtime_path);
> + return 0;
> +}
> +/*
> + * osnoise_get_period - return the original "osnoise/period_us" value
> + *
> + * It also saves the value to be restored.
> + */
> +unsigned long long osnoise_get_period(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + char *period_path;
> + long long period_us;
> + int retval;
> +
> + if (context->period_us != OSNOISE_TIME_INIT_VAL)
> + return context->period_us;
> +
> + if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_period_us;
> +
> + period_path = tracefs_get_tracing_file("osnoise/period_us");
> +
> + context->period_fd = open(period_path, O_RDWR);
> + if (context->period_fd < 0)
> + goto out_err;
> +
> + retval = read(context->period_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + period_us = get_llong_from_str(buffer);
> + if (period_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(period_path);
> +
> + context->orig_period_us = period_us;
> + return period_us;
> +
> +out_close:
> + close(context->period_fd);
> + context->period_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(period_path);
> + return 0;
> +}

osnoise_get_period() and osnoise_get_runtime() almost the same.
Use macro to generate code. Some thing also not sure now. Shame


#define osnoise_get_period osnoise_get(period)
#define osnoise_get_runtime osnoise_get(runtime)

#define osnoise_get(x) \
unsigned long long osnoise_get_##x(struct osnoise_context *context) \
{ \
char buffer[BUFF_U64_STR_SIZE]; \
char * x##_path; \
long long x##_us; \
if (context->x##_us != OSNOISE_TIME_INIT_VAL) \
return context->x##_us; \
if (context->orig_##x##_us != OSNOISE_TIME_INIT_VAL) \
return context->orig_##x##_us; \
x##_path = tracefs_get_tracing_file("osnoise/x##_us"); \
context->x##_fd = open(x##_path, O_RDWR); \
if (context->x##_fd < 0) \
goto out_err; \
retval = read(context->x##_fd, &buffer, sizeof(buffer)); \
if (retval <= 0) \
goto out_close; \
x##_us = get_llong_from_str(buffer); \
if (x##_us < 0) \
goto out_close; \
tracefs_put_tracing_file(x##_path); \
context->orig_##x##_us = x##_us; \
return x##_us; \
out_close: \
close(context->x##_fd); \
context->x##_fd = CLOSED_FD; \
out_err: \
tracefs_put_tracing_file(x##_path); \
return 0; \
}


> +
> +static int __osnoise_write_runtime(struct osnoise_context *context,
> + unsigned long long runtime)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_runtime_us == OSNOISE_TIME_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, sizeof(buffer), "%llu\n", runtime);
> +
> + retval = write(context->runtime_fd, buffer, strlen(buffer) + 1);
> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->runtime_us = runtime;
> + return 0;
> +}
> +
> +static int __osnoise_write_period(struct osnoise_context *context,
> + unsigned long long period)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_period_us == OSNOISE_TIME_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, sizeof(buffer), "%llu\n", period);
> +
> + retval = write(context->period_fd, buffer, strlen(buffer) + 1);
> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->period_us = period;
> + return 0;
> +}

__osnoise_write_period() and __osnoise_write_runtime() share
almost the same code. Macro also use in here. Not sure it is
right. Shame.

#define __osnoise_write(x) \
static int __osnoise_write_##x(struct osnoise_context *context, \
unsigned long long period) \
{ \
char buffer[BUFF_U64_STR_SIZE]; \
int retval; \
if (context->orig_##x##_us == OSNOISE_TIME_INIT_VAL) \
return -1; \
snprintf(buffer, sizeof(buffer), "%llu\n", period); \
retval = write(context->x##_fd, buffer, strlen(buffer) + 1); \
if (retval < (strlen(buffer) + 1)) \
return -1; \
context->x##_us = period; \
return 0; \
}

#define __osnoise_write_period __osnoise_write(period)
#define __osnoise_write_runtime __osnoise_write(runtime)

> +
> +/*
> + * osnoise_set_runtime_period - set osnoise runtime and period
> + *
> + * Osnoise's runtime and period are related as runtime <= period.
> + * Thus, this function saves the original values, and then tries
> + * to set the runtime and period if they are != 0.
> + */
> +int osnoise_set_runtime_period(struct osnoise_context *context,
> + unsigned long long runtime,
> + unsigned long long period)
> +{
> + unsigned long long curr_runtime_us;
> + unsigned long long curr_period_us;
> + int retval;
> +
> + if (!period && !runtime)
> + return 0;
> +
> + curr_runtime_us = osnoise_get_runtime(context);
> + curr_period_us = osnoise_get_period(context);
> +
> + /* error getting any value? */
> + if (curr_period_us == -1 || curr_runtime_us == -1)
> + return -1;

'curr_period_us' and 'curr_runtime_us' error value should be
0(OSNOISE_TIME_INIT_VAL).

> +
> + if (!period) {
> + if (runtime > curr_period_us)
> + return -1;
> + return __osnoise_write_runtime(context, runtime);
> + } else if (!runtime) {
> + if (period < curr_runtime_us)
> + return -1;
> + return __osnoise_write_period(context, period);
> + }
> +
> + if (runtime > curr_period_us) {
> + retval = __osnoise_write_period(context, period);
> + if (retval)
> + return -1;
> + retval = __osnoise_write_runtime(context, runtime);
> + if (retval)
> + return -1;
> + } else {
> + retval = __osnoise_write_runtime(context, runtime);
> + if (retval)
> + return -1;
> + retval = __osnoise_write_period(context, period);
> + if (retval)
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_get_timerlat_period_us - read and save the original "timerlat_period_us"
> + */
> +static long long
> +osnoise_get_timerlat_period_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long timerlat_period_us;
> + char *stop_path;
> + int retval;
> +
> + if (context->timerlat_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->timerlat_period_us;
> +
> + if (context->orig_timerlat_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_timerlat_period_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/timerlat_period_us");

Using timerlat_period_path seems to be straightforward.

> +
> + context->timerlat_period_us_fd = open(stop_path, O_RDWR);
> + if (context->timerlat_period_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->timerlat_period_us_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + timerlat_period_us = get_llong_from_str(buffer);
> + if (timerlat_period_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_timerlat_period_us = timerlat_period_us;
> + return timerlat_period_us;
> +
> +out_close:
> + close(context->timerlat_period_us_fd);
> + context->timerlat_period_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;

Should return 0 or OSNOISE_TIME_INIT_VAL and the return type
can be unsigned long long.

> +}
> +
> +/*
> + * osnoise_get_stop_us - read and save the original "stop_tracing_us"
> + */
> +static long long
> +osnoise_get_stop_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long stop_us;
> + char *stop_path;
> + int retval;
> +
> + if (context->stop_us != OSNOISE_OPTION_INIT_VAL)
> + return context->stop_us;
> +
> + if (context->orig_stop_us != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_stop_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_us");
> +
> + context->stop_us_fd = open(stop_path, O_RDWR);
> + if (context->stop_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->stop_us_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + stop_us = get_llong_from_str(buffer);
> + if (stop_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_stop_us = stop_us;
> + return stop_us;
> +
> +out_close:
> + close(context->stop_us_fd);
> + context->stop_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;

The same.

> +}
> +
> +/*
> + * osnoise_get_stop_total_us - read and save the original "stop_tracing_total_us"
> + */
> +static long long
> +osnoise_get_stop_total_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long stop_total_us;
> + char *stop_path;

Use stop_total_path to differentiate with stop_path used in
osnoise_get_stop_us().

> + int retval;
> +
> + if (context->stop_total_us != OSNOISE_OPTION_INIT_VAL)
> + return context->stop_total_us;
> +
> + if (context->orig_stop_total_us != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_stop_total_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_total_us");
> +
> + context->stop_total_us_fd = open(stop_path, O_RDWR);
> + if (context->stop_total_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->stop_total_us_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + stop_total_us = get_llong_from_str(buffer);
> + if (stop_total_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_stop_total_us = stop_total_us;
> + return stop_total_us;
> +
> +out_close:
> + close(context->stop_total_us_fd);
> + context->stop_total_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;

The same.

> +}
> +
> +/*
> + * osnoise_get_print_stack - read and save the original "print_stack"
> + */
> +static long long
> +osnoise_get_print_stack(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long print_stack;
> + char *stop_path;

This is print_stack_path.

> + int retval;
> +
> + if (context->print_stack != OSNOISE_OPTION_INIT_VAL)
> + return context->print_stack;
> +
> + if (context->orig_print_stack != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_print_stack;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/print_stack");
> +
> + context->print_stack_fd = open(stop_path, O_RDWR);
> + if (context->print_stack_fd < 0)
> + goto out_err;
> +
> + retval = read(context->print_stack_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + print_stack = get_llong_from_str(buffer);
> + if (print_stack < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_print_stack = print_stack;
> + return print_stack;
> +
> +out_close:
> + close(context->print_stack_fd);
> + context->print_stack_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;

The same.

> +}
> +/*
> + * osnoise_context_alloc - alloc an osnoise_context
> + *
> + * The osnoise context contains the information of the "osnoise/" configs.
> + * It is used to set and restore the config.
> + */
> +struct osnoise_context *osnoise_context_alloc(void)
> +{
> + struct osnoise_context *context;
> +
> + context = calloc(1, sizeof(*context));
> + if (!context)
> + goto out_err;
> +
> + context->cpus_fd = CLOSED_FD;
> + context->runtime_fd = CLOSED_FD;
> + context->period_fd = CLOSED_FD;
> + context->stop_us_fd = CLOSED_FD;
> + context->stop_total_us_fd = CLOSED_FD;
> + context->timerlat_period_us_fd = CLOSED_FD;
> + context->print_stack_fd = CLOSED_FD;
> +
> + context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
> + context->stop_us = OSNOISE_OPTION_INIT_VAL;
> +
> + context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
> + context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
> +
> + context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
> + context->print_stack = OSNOISE_OPTION_INIT_VAL;
> +
> + osnoise_get_context(context);
> +
> + return context;
> +out_err:
> + if (context)
> + free(context);

context is NULL here, so no need the check. Just directly return NULL
when 'if(!context)' is enough.

> + return NULL;
> +}

Sorry for my slow and not complete reply.. and leave not sure here.

Thanks,
Tao

Subject: Re: [PATCH V8 03/14] rtla: Add osnoise tool

Hi Tao

On 11/30/21 16:35, Tao Zhou wrote:
> Hi Daniel,
>
> On Mon, Nov 29, 2021 at 12:07:41PM +0100, Daniel Bristot de Oliveira wrote:
>> +/*
>> + * osnoise_restore_cpus - restore the original "osnoise/cpus"
>> + *
>> + * osnoise_set_cpus() saves the original data for the "osnoise/cpus"
>
> osnoise_set_cpus() --> osnoise_restore_cpus()

This comment is correct... osnoise_set_cpus saves the data (in the tool),
osnoise_restore_cpus() restores it.

>> + * file. This function restore the original config it was previously
>> + * modified.
>> + */
>> +void osnoise_restore_cpus(struct osnoise_context *context)
>> +{
>> + int retval;
>> +
>> + if (!context->orig_cpus)
>> + return;
>> +
>> + if (!context->curr_cpus)
>> + return;
>> +
>> + /* nothing to do? */
>> + if (!strcmp(context->orig_cpus, context->curr_cpus))
>> + goto out_done;
>> +
>> + retval = write(context->cpus_fd, context->orig_cpus, strlen(context->orig_cpus));
>
> 'strlen(context->orig_cpus) + 1' for write size;
>
>> + if (retval < strlen(context->orig_cpus))
>
> Same here. Check 'strlen(context->orig_cpus) + 1'

Fixed in v9.

>> + err_msg("could not restore original osnoise cpus\n");
>> +
>> +out_done:
>> + free(context->curr_cpus);
>> + context->curr_cpus = NULL;
>> +}
>> +
>> +/*
>> + * osnoise_get_runtime - return the original "osnoise/runtime_us" value
>> + *
>> + * It also saves the value to be restored.
>> + */
>> +unsigned long long osnoise_get_runtime(struct osnoise_context *context)
>> +{
>> + char buffer[BUFF_U64_STR_SIZE];
>> + long long runtime_us;
>> + char *runtime_path;
>> + int retval;
>> +
>> + if (context->runtime_us != OSNOISE_TIME_INIT_VAL)
>> + return context->runtime_us;
>> +
>> + if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
>> + return context->orig_runtime_us;
>> +
>> + runtime_path = tracefs_get_tracing_file("osnoise/runtime_us");
>> +
>> + context->runtime_fd = open(runtime_path, O_RDWR);
>> + if (context->runtime_fd < 0)
>> + goto out_err;
>> +
>> + retval = read(context->runtime_fd, &buffer, sizeof(buffer));
>> + if (retval <= 0)
>> + goto out_close;
>> +
>> + runtime_us = get_llong_from_str(buffer);
>> + if (runtime_us < 0)
>> + goto out_close;
>> +
>> + tracefs_put_tracing_file(runtime_path);
>> +
>> + context->orig_runtime_us = runtime_us;
>> + return runtime_us;
>> +
>> +out_close:
>> + close(context->runtime_fd);
>> + context->runtime_fd = CLOSED_FD;
>> +out_err:
>> + tracefs_put_tracing_file(runtime_path);
>> + return 0;
>> +}
>> +/*
>> + * osnoise_get_period - return the original "osnoise/period_us" value
>> + *
>> + * It also saves the value to be restored.
>> + */
>> +unsigned long long osnoise_get_period(struct osnoise_context *context)
>> +{
>> + char buffer[BUFF_U64_STR_SIZE];
>> + char *period_path;
>> + long long period_us;
>> + int retval;
>> +
>> + if (context->period_us != OSNOISE_TIME_INIT_VAL)
>> + return context->period_us;
>> +
>> + if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
>> + return context->orig_period_us;
>> +
>> + period_path = tracefs_get_tracing_file("osnoise/period_us");
>> +
>> + context->period_fd = open(period_path, O_RDWR);
>> + if (context->period_fd < 0)
>> + goto out_err;
>> +
>> + retval = read(context->period_fd, &buffer, sizeof(buffer));
>> + if (retval <= 0)
>> + goto out_close;
>> +
>> + period_us = get_llong_from_str(buffer);
>> + if (period_us < 0)
>> + goto out_close;
>> +
>> + tracefs_put_tracing_file(period_path);
>> +
>> + context->orig_period_us = period_us;
>> + return period_us;
>> +
>> +out_close:
>> + close(context->period_fd);
>> + context->period_fd = CLOSED_FD;
>> +out_err:
>> + tracefs_put_tracing_file(period_path);
>> + return 0;
>> +}
>
> osnoise_get_period() and osnoise_get_runtime() almost the same.
> Use macro to generate code. Some thing also not sure now. Shame
>
>
> #define osnoise_get_period osnoise_get(period)
> #define osnoise_get_runtime osnoise_get(runtime)
>
> #define osnoise_get(x) \
> unsigned long long osnoise_get_##x(struct osnoise_context *context) \
> { \
> char buffer[BUFF_U64_STR_SIZE]; \
> char * x##_path; \
> long long x##_us; \
> if (context->x##_us != OSNOISE_TIME_INIT_VAL) \
> return context->x##_us; \
> if (context->orig_##x##_us != OSNOISE_TIME_INIT_VAL) \
> return context->orig_##x##_us; \
> x##_path = tracefs_get_tracing_file("osnoise/x##_us"); \
> context->x##_fd = open(x##_path, O_RDWR); \
> if (context->x##_fd < 0) \
> goto out_err; \
> retval = read(context->x##_fd, &buffer, sizeof(buffer)); \
> if (retval <= 0) \
> goto out_close; \
> x##_us = get_llong_from_str(buffer); \
> if (x##_us < 0) \
> goto out_close; \
> tracefs_put_tracing_file(x##_path); \
> context->orig_##x##_us = x##_us; \
> return x##_us; \
> out_close: \
> close(context->x##_fd); \
> context->x##_fd = CLOSED_FD; \
> out_err: \
> tracefs_put_tracing_file(x##_path); \
> return 0; \
> }


I am not sure if it is worth to trade the readability for just two functions. I
will keep this as is foe now, and think about it in a second moment.

[...]
>> +
>> +/*
>> + * osnoise_set_runtime_period - set osnoise runtime and period
>> + *
>> + * Osnoise's runtime and period are related as runtime <= period.
>> + * Thus, this function saves the original values, and then tries
>> + * to set the runtime and period if they are != 0.
>> + */
>> +int osnoise_set_runtime_period(struct osnoise_context *context,
>> + unsigned long long runtime,
>> + unsigned long long period)
>> +{
>> + unsigned long long curr_runtime_us;
>> + unsigned long long curr_period_us;
>> + int retval;
>> +
>> + if (!period && !runtime)
>> + return 0;
>> +
>> + curr_runtime_us = osnoise_get_runtime(context);
>> + curr_period_us = osnoise_get_period(context);
>> +
>> + /* error getting any value? */
>> + if (curr_period_us == -1 || curr_runtime_us == -1)
>> + return -1;
>
> 'curr_period_us' and 'curr_runtime_us' error value should be
> 0(OSNOISE_TIME_INIT_VAL).
>


Right, I am now (in v9) returning the *_INIT_VAL on all errors, and using the
macro to check for errors.

[...]

>> +static long long
>> +osnoise_get_timerlat_period_us(struct osnoise_context *context)
>> +{
>> + char buffer[BUFF_U64_STR_SIZE];
>> + long long timerlat_period_us;
>> + char *stop_path;
>> + int retval;
>> +
>> + if (context->timerlat_period_us != OSNOISE_TIME_INIT_VAL)
>> + return context->timerlat_period_us;
>> +
>> + if (context->orig_timerlat_period_us != OSNOISE_TIME_INIT_VAL)
>> + return context->orig_timerlat_period_us;
>> +
>> + stop_path = tracefs_get_tracing_file("osnoise/timerlat_period_us");
>
> Using timerlat_period_path seems to be straightforward.
>

I am using config_path for all variables like this.


[...]

>> +/*
>> + * osnoise_context_alloc - alloc an osnoise_context
>> + *
>> + * The osnoise context contains the information of the "osnoise/" configs.
>> + * It is used to set and restore the config.
>> + */
>> +struct osnoise_context *osnoise_context_alloc(void)
>> +{
>> + struct osnoise_context *context;
>> +
>> + context = calloc(1, sizeof(*context));
>> + if (!context)
>> + goto out_err;
>> +
>> + context->cpus_fd = CLOSED_FD;
>> + context->runtime_fd = CLOSED_FD;
>> + context->period_fd = CLOSED_FD;
>> + context->stop_us_fd = CLOSED_FD;
>> + context->stop_total_us_fd = CLOSED_FD;
>> + context->timerlat_period_us_fd = CLOSED_FD;
>> + context->print_stack_fd = CLOSED_FD;
>> +
>> + context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
>> + context->stop_us = OSNOISE_OPTION_INIT_VAL;
>> +
>> + context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
>> + context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
>> +
>> + context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
>> + context->print_stack = OSNOISE_OPTION_INIT_VAL;
>> +
>> + osnoise_get_context(context);
>> +
>> + return context;
>> +out_err:
>> + if (context)
>> + free(context);
>
> context is NULL here, so no need the check. Just directly return NULL
> when 'if(!context)' is enough.
>
>> + return NULL;
>> +}

In v9, I am removing the goto, returning NULL if (!context).

> Sorry for my slow and not complete reply.. and leave not sure here.
>
> Thanks,
> Tao

Thanks Tao
-- Daniel


2021-12-03 09:08:03

by Tao Zhou

[permalink] [raw]
Subject: Re: [PATCH V8 02/14] rtla: Helper functions for rtla

On Mon, Nov 29, 2021 at 12:07:40PM +0100,
Daniel Bristot de Oliveira wrote:

> +/*
> + * enable_tracer_by_name - enable a tracer on the given instance
> + */
> +int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer)
> +{
> + enum tracefs_tracers t;
> + int retval;
> +
> + t = TRACEFS_TRACER_CUSTOM;
> +
> + debug_msg("enabling %s tracer\n", tracer);
> +
> + retval = tracefs_tracer_set(inst, t, tracer);

The comment of parameters used for tracefs_tracer_set() says:

'
* tracefs_set_tracer - function to set the tracer
* @instance: ftrace instance, can be NULL for top tracing instance
* @tracer: The tracer enum that defines the tracer to be set
* @t: A tracer name if TRACEFS_TRACER_CUSTOM is passed in for @tracer
'

tracefs_tracer_set(inst, tracer, t); @tracer is enum and @t is tracer
name. this is not important.

> + if (retval < 0) {
> + if (errno == ENODEV)
> + err_msg("tracer %s not found!\n", tracer);
> +
> + err_msg("failed to enable the tracer %s\n", tracer);
> + return -1;
> + }
> +
> + return 0;
> +}

2021-12-03 09:14:13

by Tao Zhou

[permalink] [raw]
Subject: Re: [PATCH V8 06/14] rtla: Add timerlat tool and timelart top mode

On Mon, Nov 29, 2021 at 12:07:44PM +0100,
Daniel Bristot de Oliveira wrote:

> The rtla timerlat tool is an interface for the timerlat tracer.
> The timerlat tracer dispatches a kernel thread per-cpu. These threads set a
> periodic timer to wake themselves up and go back to sleep. After the
> wakeup, they collect and generate useful information for the debugging of
> operating system timer latency.
>
> The timerlat tracer outputs information in two ways. It periodically
> prints the timer latency at the timer IRQ handler and the Thread handler.
> It also provides information for each noise via the osnoise tracepoints.
>
> The rtla timerlat top mode displays a summary of the periodic output from
> the timerlat tracer.
>
> Here is one example of the rtla timerlat tool output:
> ---------- %< ----------
> [root@alien ~]# rtla timerlat top -c 0-3 -d 1m
> Timer Latency
> 0 00:01:00 | IRQ Timer Latency (us) | Thread Timer Latency (us)
> CPU COUNT | cur min avg max | cur min avg max
> 0 #60001 | 0 0 0 3 | 1 1 1 6
> 1 #60001 | 0 0 0 3 | 2 1 1 5
> 2 #60001 | 0 0 1 6 | 1 1 2 7
> 3 #60001 | 0 0 0 7 | 1 1 1 11
> ---------- >% ----------
>
> Running:
> # rtla timerlat --help
> # rtla timerlat top --help
> provides information about the available options.
>
> Cc: Steven Rostedt <[email protected]>
> Cc: Ingo Molnar <[email protected]>
> Cc: Tom Zanussi <[email protected]>
> Cc: Masami Hiramatsu <[email protected]>
> Cc: Juri Lelli <[email protected]>
> Cc: Clark Williams <[email protected]>
> Cc: John Kacur <[email protected]>
> Cc: Peter Zijlstra <[email protected]>
> Cc: Thomas Gleixner <[email protected]>
> Cc: Sebastian Andrzej Siewior <[email protected]>
> Cc: Daniel Bristot de Oliveira <[email protected]>
> Cc: [email protected]
> Cc: [email protected]
> Cc: [email protected]
> Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
> ---
> tools/tracing/rtla/Makefile | 2 +
> tools/tracing/rtla/src/rtla.c | 5 +
> tools/tracing/rtla/src/timerlat.c | 68 +++
> tools/tracing/rtla/src/timerlat.h | 4 +
> tools/tracing/rtla/src/timerlat_top.c | 615 ++++++++++++++++++++++++++
> 5 files changed, 694 insertions(+)
> create mode 100644 tools/tracing/rtla/src/timerlat.c
> create mode 100644 tools/tracing/rtla/src/timerlat.h
> create mode 100644 tools/tracing/rtla/src/timerlat_top.c
>
> diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
> index ba6f327e815a..f254cfbe4fa3 100644
> --- a/tools/tracing/rtla/Makefile
> +++ b/tools/tracing/rtla/Makefile
> @@ -62,6 +62,8 @@ install:
> $(STRIP) $(DESTDIR)$(BINDIR)/rtla
> @test ! -f $(DESTDIR)$(BINDIR)/osnoise || rm $(DESTDIR)$(BINDIR)/osnoise
> ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/osnoise
> + @test ! -f $(DESTDIR)$(BINDIR)/timerlat || rm $(DESTDIR)$(BINDIR)/timerlat
> + ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/timerlat
>
> .PHONY: clean tarball
> clean:
> diff --git a/tools/tracing/rtla/src/rtla.c b/tools/tracing/rtla/src/rtla.c
> index 669b9750b3b3..09bd21b8af81 100644
> --- a/tools/tracing/rtla/src/rtla.c
> +++ b/tools/tracing/rtla/src/rtla.c
> @@ -9,6 +9,7 @@
> #include <stdio.h>
>
> #include "osnoise.h"
> +#include "timerlat.h"
>
> /*
> * rtla_usage - print rtla usage
> @@ -25,6 +26,7 @@ static void rtla_usage(void)
> "",
> " commands:",
> " osnoise - gives information about the operating system noise (osnoise)",
> + " timerlat - measures the timer irq and thread latency",
> "",
> NULL,
> };
> @@ -45,6 +47,9 @@ int run_command(int argc, char **argv, int start_position)
> if (strcmp(argv[start_position], "osnoise") == 0) {
> osnoise_main(argc-start_position, &argv[start_position]);
> goto ran;
> + } else if (strcmp(argv[start_position], "timerlat") == 0) {
> + timerlat_main(argc-start_position, &argv[start_position]);
> + goto ran;
> }
>
> return 0;
> diff --git a/tools/tracing/rtla/src/timerlat.c b/tools/tracing/rtla/src/timerlat.c
> new file mode 100644
> index 000000000000..29a51c01b084
> --- /dev/null
> +++ b/tools/tracing/rtla/src/timerlat.c
> @@ -0,0 +1,68 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
> + */
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <pthread.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +
> +#include "timerlat.h"
> +
> +static void timerlat_usage(void)
> +{
> + int i;
> +
> + static const char * const msg[] = {
> + "",
> + "timerlat version " VERSION,
> + "",
> + " usage: [rtla] timerlat [MODE] ...",
> + "",
> + " modes:",
> + " top - prints the summary from timerlat tracer",
> + "",
> + "if no MODE is given, the top mode is called, passing the arguments",
> + NULL,
> + };
> +
> + for (i = 0; msg[i]; i++)
> + fprintf(stderr, "%s\n", msg[i]);
> + exit(1);
> +}
> +
> +int timerlat_main(int argc, char *argv[])
> +{
> + if (argc == 0)
> + goto usage;
> +
> + /*
> + * if timerlat was called without any argument, run the
> + * default cmdline.
> + */
> + if (argc == 1) {
> + timerlat_top_main(argc, argv);
> + exit(0);
> + }
> +
> + if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
> + timerlat_usage();
> + exit(0);
> + } else if (strncmp(argv[1], "-", 1) == 0) {
> + /* the user skipped the tool, call the default one */
> + timerlat_top_main(argc, argv);
> + exit(0);
> + } else if (strcmp(argv[1], "top") == 0) {
> + timerlat_top_main(argc-1, &argv[1]);
> + exit(0);
> + }
> +
> +usage:
> + timerlat_usage();
> + exit(1);
> +}
> diff --git a/tools/tracing/rtla/src/timerlat.h b/tools/tracing/rtla/src/timerlat.h
> new file mode 100644
> index 000000000000..6f9d3925acd0
> --- /dev/null
> +++ b/tools/tracing/rtla/src/timerlat.h
> @@ -0,0 +1,4 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +int timerlat_top_main(int argc, char *argv[]);
> +int timerlat_main(int argc, char *argv[]);
> diff --git a/tools/tracing/rtla/src/timerlat_top.c b/tools/tracing/rtla/src/timerlat_top.c
> new file mode 100644
> index 000000000000..9764681ad8b1
> --- /dev/null
> +++ b/tools/tracing/rtla/src/timerlat_top.c
> @@ -0,0 +1,615 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
> + */
> +
> +#include <getopt.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <signal.h>
> +#include <unistd.h>
> +#include <stdio.h>
> +#include <time.h>
> +
> +#include "utils.h"
> +#include "osnoise.h"
> +#include "timerlat.h"
> +
> +struct timerlat_top_params {
> + char *cpus;
> + char *monitored_cpus;
> + char *trace_output;
> + unsigned long long runtime;
> + long long stop_us;
> + long long stop_total_us;
> + long long timerlat_period_us;
> + long long print_stack;
> + int sleep_time;
> + int output_divisor;
> + int duration;
> + int quiet;
> + int set_sched;
> + struct sched_attr sched_param;
> +};
> +
> +struct timerlat_top_cpu {
> + int irq_count;
> + int thread_count;
> +
> + unsigned long long cur_irq;
> + unsigned long long min_irq;
> + unsigned long long sum_irq;
> + unsigned long long max_irq;
> +
> + unsigned long long cur_thread;
> + unsigned long long min_thread;
> + unsigned long long sum_thread;
> + unsigned long long max_thread;
> +};
> +
> +struct timerlat_top_data {
> + struct timerlat_top_cpu *cpu_data;
> + int nr_cpus;
> +};
> +
> +/*
> + * timerlat_free_top - free runtime data
> + */
> +static void
> +timerlat_free_top(struct timerlat_top_data *data)
> +{
> + free(data->cpu_data);
> + free(data);
> +}
> +
> +/*
> + * timerlat_alloc_histogram - alloc runtime data
> + */
> +static struct timerlat_top_data *timerlat_alloc_top(int nr_cpus)
> +{
> + struct timerlat_top_data *data;
> + int cpu;
> +
> + data = calloc(1, sizeof(*data));
> + if (!data)
> + return NULL;
> +
> + data->nr_cpus = nr_cpus;
> +
> + /* one set of histograms per CPU */
> + data->cpu_data = calloc(1, sizeof(*data->cpu_data) * nr_cpus);
> + if (!data->cpu_data)
> + goto cleanup;
> +
> + /* set the min to max */
> + for (cpu = 0; cpu < nr_cpus; cpu++) {
> + data->cpu_data[cpu].min_irq = ~0;
> + data->cpu_data[cpu].min_thread = ~0;
> + }
> +
> + return data;
> +
> +cleanup:
> + timerlat_free_top(data);
> + return NULL;
> +}
> +
> +/*
> + * timerlat_hist_update - record a new timerlat occurent on cpu, updating data
> + */
> +static void
> +timerlat_top_update(struct osnoise_tool *tool, int cpu,
> + unsigned long long thread,
> + unsigned long long latency)
> +{
> + struct timerlat_top_data *data = tool->data;
> + struct timerlat_top_cpu *cpu_data = &data->cpu_data[cpu];
> +
> + if (!thread) {
> + cpu_data->irq_count++;
> + cpu_data->cur_irq = latency;
> + update_min(&cpu_data->min_irq, &latency);
> + update_sum(&cpu_data->sum_irq, &latency);
> + update_max(&cpu_data->max_irq, &latency);
> + } else {
> + cpu_data->thread_count++;
> + cpu_data->cur_thread = latency;
> + update_min(&cpu_data->min_thread, &latency);
> + update_sum(&cpu_data->sum_thread, &latency);
> + update_max(&cpu_data->max_thread, &latency);
> + }
> +}
> +
> +/*
> + * timerlat_top_handler - this is the handler for timerlat tracer events
> + */
> +static int
> +timerlat_top_handler(struct trace_seq *s, struct tep_record *record,
> + struct tep_event *event, void *context)
> +{
> + struct trace_instance *trace = context;
> + unsigned long long latency, thread;
> + struct osnoise_tool *top;
> + int cpu = record->cpu;
> +
> + top = container_of(trace, struct osnoise_tool, trace);
> +
> + tep_get_field_val(s, event, "context", record, &thread, 1);
> + tep_get_field_val(s, event, "timer_latency", record, &latency, 1);
> +
> + timerlat_top_update(top, cpu, thread, latency);
> +
> + return 0;
> +}
> +
> +/*
> + * timerlat_top_header - print the header of the tool output
> + */
> +static void timerlat_top_header(struct osnoise_tool *top)
> +{
> + struct timerlat_top_params *params = top->params;
> + struct trace_seq *s = top->trace.seq;
> + char duration[26];
> +
> + get_duration(top->start_time, duration, sizeof(duration));
> +
> + trace_seq_printf(s, "\033[2;37;40m");
> + trace_seq_printf(s, " Timer Latency ");
> + trace_seq_printf(s, "\033[0;0;0m");
> + trace_seq_printf(s, "\n");
> +
> + trace_seq_printf(s, "%-6s | IRQ Timer Latency (%s) | Thread Timer Latency (%s)\n", duration,
> + params->output_divisor == 1 ? "ns" : "us",
> + params->output_divisor == 1 ? "ns" : "us");
> +
> + trace_seq_printf(s, "\033[2;30;47m");
> + trace_seq_printf(s, "CPU COUNT | cur min avg max | cur min avg max");
> + trace_seq_printf(s, "\033[0;0;0m");
> + trace_seq_printf(s, "\n");
> +}
> +
> +/*
> + * timerlat_top_print - prints the output of a given CPU
> + */
> +static void timerlat_top_print(struct osnoise_tool *top, int cpu)
> +{
> +
> + struct timerlat_top_params *params = top->params;
> + struct timerlat_top_data *data = top->data;
> + struct timerlat_top_cpu *cpu_data = &data->cpu_data[cpu];
> + int divisor = params->output_divisor;
> + struct trace_seq *s = top->trace.seq;
> +
> + if (divisor == 0)
> + return;
> +
> + /*
> + * Skip if no data is available: is this cpu offline?
> + */
> + if (!cpu_data->irq_count && !cpu_data->thread_count)
> + return;
> +
> + /*
> + * Unless trace is being lost, IRQ counter is always the max.
> + */
> + trace_seq_printf(s, "%3d #%-9d |", cpu, cpu_data->irq_count);
> +
> + if (!cpu_data->irq_count) {
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " - |");
> + } else {
> + trace_seq_printf(s, "%9llu ", cpu_data->cur_irq / params->output_divisor);
> + trace_seq_printf(s, "%9llu ", cpu_data->min_irq / params->output_divisor);
> + trace_seq_printf(s, "%9llu ", (cpu_data->sum_irq / cpu_data->irq_count) / divisor);
> + trace_seq_printf(s, "%9llu |", cpu_data->max_irq / divisor);
> + }
> +
> + if (!cpu_data->thread_count) {
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " - ");
> + trace_seq_printf(s, " -\n");
> + } else {
> + trace_seq_printf(s, "%9llu ", cpu_data->cur_thread / divisor);
> + trace_seq_printf(s, "%9llu ", cpu_data->min_thread / divisor);
> + trace_seq_printf(s, "%9llu ",
> + (cpu_data->sum_thread / cpu_data->thread_count) / divisor);
> + trace_seq_printf(s, "%9llu\n", cpu_data->max_thread / divisor);
> + }
> +}
> +
> +/*
> + * clear_terminal - clears the output terminal
> + */
> +static void clear_terminal(struct trace_seq *seq)
> +{
> + if (!config_debug)
> + trace_seq_printf(seq, "\033c");
> +}
> +
> +/*
> + * timerlat_print_stats - print data for all cpus
> + */
> +static void
> +timerlat_print_stats(struct timerlat_top_params *params, struct osnoise_tool *top)
> +{
> + struct trace_instance *trace = &top->trace;
> + static int nr_cpus = -1;
> + int i;
> +
> + if (nr_cpus == -1)
> + nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
> +
> + if (!params->quiet)
> + clear_terminal(trace->seq);
> +
> + timerlat_top_header(top);
> +
> + for (i = 0; i < nr_cpus; i++) {
> + if (params->cpus && !params->monitored_cpus[i])
> + continue;
> + timerlat_top_print(top, i);
> + }
> +
> + trace_seq_do_printf(trace->seq);
> + trace_seq_reset(trace->seq);
> +}
> +
> +/*
> + * timerlat_top_usage - prints timerlat top usage message
> + */
> +static void timerlat_top_usage(char *usage)
> +{
> + int i;
> +
> + static const char *const msg[] = {
> + "",
> + " usage: rtla timerlat [top] [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
> + " [-c cpu-list] [-P priority]",
> + "",
> + " -h/--help: print this menu",
> + " -p/--period us: timerlat period in us",
> + " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
> + " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
> + " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
> + " -c/--cpus cpus: run the tracer only on the given cpus -d/--duration time[m|h|d]: duration of the session in seconds",
> + " -t/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
> + " -n/--nano: display data in nanoseconds",
> + " -q/--quiet print only a summary at the end",
> + " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
> + " o:prio - use SCHED_OTHER with prio",
> + " r:prio - use SCHED_RR with prio",
> + " f:prio - use SCHED_FIFO with prio",
> + " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
> + " in nanoseconds",
> + NULL,
> + };

About help usage msg.

[-t us] --> [-T us]
[-T=[file]] --> [-t[=file]]

[-d] [-D] [-n] lack in the head usage info 'usage: ...'

> +
> + if (usage)
> + fprintf(stderr, "%s\n", usage);
> +
> + fprintf(stderr, "rtla timerlat top: a per-cpu summary of the timer latency (version %s)\n",
> + VERSION);
> +
> + for (i = 0; msg[i]; i++)
> + fprintf(stderr, "%s\n", msg[i]);
> + exit(1);
> +}
> +

2021-12-03 09:18:08

by Tao Zhou

[permalink] [raw]
Subject: Re: [PATCH V8 07/14] rtla/timerlat: Add timerlat hist mode

On Mon, Nov 29, 2021 at 12:07:45PM +0100,
Daniel Bristot de Oliveira wrote:

> +static void timerlat_hist_usage(char *usage)
> +{
> + int i;
> +
> + char *msg[] = {
> + "",
> + " usage: [rtla] timerlat hist [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
> + " [-c cpu-list] [-P priority] [--no-irq] [--no-thread] [--no-header] [--no-summary] \\",
> + " [--no-index] [--with-zeros]",
> + "",
> + " -h/--help: print this menu",
> + " -p/--period us: timerlat period in us",
> + " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
> + " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
> + " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
> + " -c/--cpus cpus: run the tracer only on the given cpus",
> + " -d/--duration time[m|h|d]: duration of the session in seconds",
> + " -T/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
> + " -n/--nano: display data in nanoseconds",
> + " -b/--bucket-size N: set the histogram bucket size (default 1)",
> + " -e/--entries N: set the number of entries of the histogram (default 256)",
> + " --no-irq: ignore IRQ latencies",
> + " --no-thread: ignore thread latencies",
> + " --no-header: do not print header",
> + " --no-summary: do not print summary",
> + " --no-index: do not print index",
> + " --with-zeros: print zero only entries",
> + " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
> + " o:prio - use SCHED_OTHER with prio",
> + " r:prio - use SCHED_RR with prio",
> + " f:prio - use SCHED_FIFO with prio",
> + " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
> + " in nanoseconds",
> + NULL,
> + };

[-t us] --> [-T us]
[-T[=file]] --> [-t[=file]]
[-d] [-b] [-e] [-n] lack in usage info. this is not important tho.

Subject: Re: [PATCH V8 02/14] rtla: Helper functions for rtla

On 12/3/21 10:07, Tao Zhou wrote:
> On Mon, Nov 29, 2021 at 12:07:40PM +0100,
> Daniel Bristot de Oliveira wrote:
>
>> +/*
>> + * enable_tracer_by_name - enable a tracer on the given instance
>> + */
>> +int enable_tracer_by_name(struct tracefs_instance *inst, const char *tracer)
>> +{
>> + enum tracefs_tracers t;
>> + int retval;
>> +
>> + t = TRACEFS_TRACER_CUSTOM;
>> +
>> + debug_msg("enabling %s tracer\n", tracer);
>> +
>> + retval = tracefs_tracer_set(inst, t, tracer);
> The comment of parameters used for tracefs_tracer_set() says:
>
> '
> * tracefs_set_tracer - function to set the tracer
> * @instance: ftrace instance, can be NULL for top tracing instance
> * @tracer: The tracer enum that defines the tracer to be set
> * @t: A tracer name if TRACEFS_TRACER_CUSTOM is passed in for @tracer
> '
>
> tracefs_tracer_set(inst, tracer, t); @tracer is enum and @t is tracer
> name. this is not important.
>

cosmetics.

Anyway: s/tracer/tracer_name/ ; s/t/tracer/

-- Daniel



Subject: Re: [PATCH V8 06/14] rtla: Add timerlat tool and timelart top mode

On 12/3/21 10:13, Tao Zhou wrote:
>> +/*
>> + * timerlat_top_usage - prints timerlat top usage message
>> + */
>> +static void timerlat_top_usage(char *usage)
>> +{
>> + int i;
>> +
>> + static const char *const msg[] = {
>> + "",
>> + " usage: rtla timerlat [top] [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
>> + " [-c cpu-list] [-P priority]",
>> + "",
>> + " -h/--help: print this menu",
>> + " -p/--period us: timerlat period in us",
>> + " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
>> + " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
>> + " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
>> + " -c/--cpus cpus: run the tracer only on the given cpus -d/--duration time[m|h|d]: duration of the session in seconds",
>> + " -t/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
>> + " -n/--nano: display data in nanoseconds",
>> + " -q/--quiet print only a summary at the end",
>> + " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
>> + " o:prio - use SCHED_OTHER with prio",
>> + " r:prio - use SCHED_RR with prio",
>> + " f:prio - use SCHED_FIFO with prio",
>> + " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
>> + " in nanoseconds",
>> + NULL,
>> + };
> About help usage msg.
>
> [-t us] --> [-T us]
> [-T=[file]] --> [-t[=file]]
>
> [-d] [-D] [-n] lack in the head usage info 'usage: ...'
>

Fixed in V9

-- Daniel

Subject: Re: [PATCH V8 07/14] rtla/timerlat: Add timerlat hist mode

On 12/3/21 10:17, Tao Zhou wrote:
> On Mon, Nov 29, 2021 at 12:07:45PM +0100,
> Daniel Bristot de Oliveira wrote:
>
>> +static void timerlat_hist_usage(char *usage)
>> +{
>> + int i;
>> +
>> + char *msg[] = {
>> + "",
>> + " usage: [rtla] timerlat hist [-h] [-q] [-p us] [-i us] [-t us] [-s us] [-T[=file]] \\",
>> + " [-c cpu-list] [-P priority] [--no-irq] [--no-thread] [--no-header] [--no-summary] \\",
>> + " [--no-index] [--with-zeros]",
>> + "",
>> + " -h/--help: print this menu",
>> + " -p/--period us: timerlat period in us",
>> + " -i/--irq us: stop trace if the irq latency is higher than the argument in us",
>> + " -T/--thread us: stop trace if the thread latency is higher than the argument in us",
>> + " -s/--stack us: save the stack trace at the IRQ if a thread latency is higher than the argument in us",
>> + " -c/--cpus cpus: run the tracer only on the given cpus",
>> + " -d/--duration time[m|h|d]: duration of the session in seconds",
>> + " -T/--trace[=file]: save the stopped trace to [file|timerlat_trace.txt]",
>> + " -n/--nano: display data in nanoseconds",
>> + " -b/--bucket-size N: set the histogram bucket size (default 1)",
>> + " -e/--entries N: set the number of entries of the histogram (default 256)",
>> + " --no-irq: ignore IRQ latencies",
>> + " --no-thread: ignore thread latencies",
>> + " --no-header: do not print header",
>> + " --no-summary: do not print summary",
>> + " --no-index: do not print index",
>> + " --with-zeros: print zero only entries",
>> + " -P/--priority o:prio|r:prio|f:prio|d:runtime:period : set scheduling parameters",
>> + " o:prio - use SCHED_OTHER with prio",
>> + " r:prio - use SCHED_RR with prio",
>> + " f:prio - use SCHED_FIFO with prio",
>> + " d:runtime[us|ms|s]:period[us|ms|s] - use SCHED_DEADLINE with runtime and period",
>> + " in nanoseconds",
>> + NULL,
>> + };
>
> [-t us] --> [-T us]
> [-T[=file]] --> [-t[=file]]
> [-d] [-b] [-e] [-n] lack in usage info. this is not important tho.
>

Fixed in V9

-- Daniel

2021-12-04 13:25:29

by Tao Zhou

[permalink] [raw]
Subject: Re: [PATCH V8 00/14] RTLA: An interface for osnoise/timerlat tracers

On Mon, Nov 29, 2021 at 12:07:38PM +0100, Daniel Bristot de Oliveira wrote:

> The rtla(1) is a meta-tool that includes a set of commands that
> aims to analyze the real-time properties of Linux. But instead of
> testing Linux as a black box, rtla leverages kernel tracing
> capabilities to provide precise information about the properties
> and root causes of unexpected results.
>
> To start, it presents an interface to the osnoise and timerlat tracers.
> In the future, it will also serve as home to the rtsl [1] and other
> latency/noise tracers.
>
> If you just want to run it, you can download the tarball here:
> - https://bristot.me/files/rtla/tarball/rtla-0.4.tar.bz2
>
> To compile rtla on fedora you need:
> $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
> $ cd libtraceevent/
> $ make
> $ sudo make install
> $ cd ..
> $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
> $ cd libtracefs/
> $ make
> $ sudo make install
> $ cd ..
> $ sudo dnf install python3-docutils procps-devel
> $ cd $rtla_src
> $ make
> $ sudo make install

Set osnoise/x to DEADLINE, the return is not success. see:

tao@geo ~/opensource/rtla-0.4 $ sudo rtla osnoise top -P d:100us:1ms -c 0-3 -r 900000 -d 1M -q
boost_with_deadline failed to boost pid 4766: Operation not permitted
Failed to set sched parameters

top shows:

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
4773 root 20 0 0 0 0 R 89.4 0.0 2:06.88 osnoise/0
4776 root 20 0 0 0 0 R 89.4 0.0 2:06.88 osnoise/3
4774 root 20 0 0 0 0 R 89.0 0.0 2:06.88 osnoise/1
4775 root 20 0 0 0 0 R 88.7 0.0 2:06.69 osnoise/2

t

Subject: Re: [PATCH V8 00/14] RTLA: An interface for osnoise/timerlat tracers

On 12/4/21 14:25, Tao Zhou wrote:
> On Mon, Nov 29, 2021 at 12:07:38PM +0100, Daniel Bristot de Oliveira wrote:
>
>> The rtla(1) is a meta-tool that includes a set of commands that
>> aims to analyze the real-time properties of Linux. But instead of
>> testing Linux as a black box, rtla leverages kernel tracing
>> capabilities to provide precise information about the properties
>> and root causes of unexpected results.
>>
>> To start, it presents an interface to the osnoise and timerlat tracers.
>> In the future, it will also serve as home to the rtsl [1] and other
>> latency/noise tracers.
>>
>> If you just want to run it, you can download the tarball here:
>> - https://bristot.me/files/rtla/tarball/rtla-0.4.tar.bz2
>>
>> To compile rtla on fedora you need:
>> $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtraceevent.git
>> $ cd libtraceevent/
>> $ make
>> $ sudo make install
>> $ cd ..
>> $ git clone git://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git
>> $ cd libtracefs/
>> $ make
>> $ sudo make install
>> $ cd ..
>> $ sudo dnf install python3-docutils procps-devel
>> $ cd $rtla_src
>> $ make
>> $ sudo make install
>
> Set osnoise/x to DEADLINE, the return is not success. see:
>
> tao@geo ~/opensource/rtla-0.4 $ sudo rtla osnoise top -P d:100us:1ms -c 0-3 -r 900000 -d 1M -q
> boost_with_deadline failed to boost pid 4766: Operation not permitted
> Failed to set sched parameters

Did you disable the admission control?

e.g.,

$ sudo sysctl -w kernel.sched_rt_runtime_us=-1

-- Daniel

Subject: Re: [PATCH V8 04/14] rtla/osnoise: Add osnoise top mode

Tao


On 11/29/21 12:07, Daniel Bristot de Oliveira wrote:
> +int osnoise_top_main(int argc, char **argv)
> +{
> + struct osnoise_top_params *params;
> + struct trace_instance *trace;
> + struct osnoise_tool *record;
> + struct osnoise_tool *tool;
> + int return_value = 1;
> + int retval;
> +
> + params = osnoise_top_parse_args(argc, argv);
> + if (!params)
> + exit(1);
> +
> + tool = osnoise_init_top(params);
> + if (!tool) {
> + err_msg("Could not init osnoise top\n");
> + goto out_exit;
> + }
> +
> + retval = osnoise_top_apply_config(tool, params);
> + if (retval) {
> + err_msg("Could not apply config\n");
> + goto out_top;
> + }
> +
> + trace = &tool->trace;
> +
> + retval = enable_osnoise(trace);
> + if (retval) {
> + err_msg("Failed to enable osnoise tracer\n");
> + goto out_top;
> + }
> +
> + if (params->set_sched) {
> + retval = set_comm_sched_attr("osnoise/", &params->sched_param);
> + if (retval)


You hit this case. It is correct to get this error if one sets SCHED_DEADLINE
without disabling the admission control.

However, there is also a problem here. The tracer was not disabled, and the
instance was not removed - so osnoise threads kept running after the error
message and exit().

I will fix this on all tools for v9.

Thanks for testing!
--- Daniel

> + osnoise_top_usage("Failed to set sched parameters\n");
> + }
> +


2021-12-08 22:13:21

by Steven Rostedt

[permalink] [raw]
Subject: Re: [PATCH V8 03/14] rtla: Add osnoise tool

On Mon, 29 Nov 2021 12:07:41 +0100
Daniel Bristot de Oliveira <[email protected]> wrote:

> The osnoise tool is the interface for the osnoise tracer. The osnoise
> tool will have multiple "modes" with different outputs. At this point,
> no mode is included.
>
> The osnoise.c includes the osnoise_context abstraction. It serves to
> read-save-change-restore the default values from tracing/osnoise/
> directory. When the context is deleted, the default values are restored.
>
> It also includes some other helper functions for managing osnoise
> tracer sessions.
>
> With these bits and pieces in place, we can start adding some
> functionality to rtla.
>
> Cc: Steven Rostedt <[email protected]>
> Cc: Ingo Molnar <[email protected]>
> Cc: Tom Zanussi <[email protected]>
> Cc: Masami Hiramatsu <[email protected]>
> Cc: Juri Lelli <[email protected]>
> Cc: Clark Williams <[email protected]>
> Cc: John Kacur <[email protected]>
> Cc: Peter Zijlstra <[email protected]>
> Cc: Thomas Gleixner <[email protected]>
> Cc: Sebastian Andrzej Siewior <[email protected]>
> Cc: Daniel Bristot de Oliveira <[email protected]>
> Cc: [email protected]
> Cc: [email protected]
> Cc: [email protected]
> Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
> ---
> tools/tracing/rtla/Makefile | 2 +
> tools/tracing/rtla/src/osnoise.c | 1013 ++++++++++++++++++++++++++++++
> tools/tracing/rtla/src/osnoise.h | 95 +++
> tools/tracing/rtla/src/rtla.c | 10 +
> 4 files changed, 1120 insertions(+)
> create mode 100644 tools/tracing/rtla/src/osnoise.c
> create mode 100644 tools/tracing/rtla/src/osnoise.h
>
> diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
> index d99ea2d8b87e..ba6f327e815a 100644
> --- a/tools/tracing/rtla/Makefile
> +++ b/tools/tracing/rtla/Makefile
> @@ -60,6 +60,8 @@ install:
> $(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)
> $(INSTALL) rtla -m 755 $(DESTDIR)$(BINDIR)
> $(STRIP) $(DESTDIR)$(BINDIR)/rtla
> + @test ! -f $(DESTDIR)$(BINDIR)/osnoise || rm $(DESTDIR)$(BINDIR)/osnoise
> + ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/osnoise
>
> .PHONY: clean tarball
> clean:
> diff --git a/tools/tracing/rtla/src/osnoise.c b/tools/tracing/rtla/src/osnoise.c
> new file mode 100644
> index 000000000000..7ef686dddc09
> --- /dev/null
> +++ b/tools/tracing/rtla/src/osnoise.c
> @@ -0,0 +1,1013 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
> + */
> +
> +#include <sys/types.h>
> +#include <sys/stat.h>
> +#include <pthread.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <errno.h>
> +#include <fcntl.h>
> +#include <stdio.h>
> +
> +#include "osnoise.h"
> +#include "utils.h"
> +
> +/*
> + * osnoise_get_cpus - return the original "osnoise/cpus" content
> + *
> + * It also saves the value to be restored.
> + */
> +char *osnoise_get_cpus(struct osnoise_context *context)
> +{
> + char buffer[1024];
> + char *cpus_path;
> + int retval;
> +
> + if (context->curr_cpus)
> + return context->curr_cpus;
> +
> + if (context->orig_cpus)
> + return context->orig_cpus;
> +
> + cpus_path = tracefs_get_tracing_file("osnoise/cpus");
> +
> + context->cpus_fd = open(cpus_path, O_RDWR);
> + if (context->cpus_fd < 0)
> + goto out_err;
> +
> + retval = read(context->cpus_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + context->orig_cpus = strdup(buffer);


Or you could have done:

context->orig_cpus = tracefs_instance_read(NULL, "osnoise/cpus");

as I doubt that reading and writing the cpus file you really care about
keeping around the file descriptor. It's not something likely to be done
where you care about "disrupting" the system. But if you really do care:

context->cpus_fd = tracefs_instance_file_open(NULL, "osnoise/cpus",
O_RDWR);



> + if (!context->orig_cpus)
> + goto out_close;
> +
> + tracefs_put_tracing_file(cpus_path);
> +
> + return context->orig_cpus;
> +
> +out_close:
> + close(context->cpus_fd);
> +out_err:
> + tracefs_put_tracing_file(cpus_path);
> + return NULL;
> +}
> +
> +/*
> + * osnoise_set_cpus - configure osnoise to run on *cpus
> + *
> + * "osnoise/cpus" file is used to set the cpus in which osnoise/timerlat
> + * will run. This function opens this file, saves the current value,
> + * and set the cpus passed as argument.
> + */
> +int osnoise_set_cpus(struct osnoise_context *context, char *cpus)
> +{
> + char *orig_cpus = osnoise_get_cpus(context);
> + int retval;
> +
> + if (!orig_cpus)
> + return -1;
> +
> + context->curr_cpus = strdup(cpus);
> + if (!context->curr_cpus)
> + return -1;
> +
> + retval = write(context->cpus_fd, cpus, strlen(cpus) + 1);


retval = tracefs_instance_file_write(NULL, "osnoise/cpus", cpus);

> + if (retval < (strlen(cpus) + 1)) {
> + free(context->curr_cpus);
> + context->curr_cpus = NULL;
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_cpus - restore the original "osnoise/cpus"
> + *
> + * osnoise_set_cpus() saves the original data for the "osnoise/cpus"
> + * file. This function restore the original config it was previously
> + * modified.
> + */
> +void osnoise_restore_cpus(struct osnoise_context *context)
> +{
> + int retval;
> +
> + if (!context->orig_cpus)
> + return;
> +
> + if (!context->curr_cpus)
> + return;
> +
> + /* nothing to do? */
> + if (!strcmp(context->orig_cpus, context->curr_cpus))
> + goto out_done;
> +
> + retval = write(context->cpus_fd, context->orig_cpus, strlen(context->orig_cpus));

retval = tracefs_instance_file_write(NULL, "osnoise/cpus", context->orig_cpus);

> + if (retval < strlen(context->orig_cpus))
> + err_msg("could not restore original osnoise cpus\n");
> +
> +out_done:
> + free(context->curr_cpus);
> + context->curr_cpus = NULL;
> +}
> +
> +/*
> + * osnoise_put_cpus - restore cpus config and cleanup data
> + */
> +void osnoise_put_cpus(struct osnoise_context *context)
> +{
> + osnoise_restore_cpus(context);
> +
> + if (!context->orig_cpus)
> + return;
> +
> + free(context->orig_cpus);
> + context->orig_cpus = NULL;
> + close(context->cpus_fd);
> + context->cpus_fd = CLOSED_FD;
> +}
> +
> +/*
> + * osnoise_get_runtime - return the original "osnoise/runtime_us" value
> + *
> + * It also saves the value to be restored.
> + */
> +unsigned long long osnoise_get_runtime(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long runtime_us;
> + char *runtime_path;
> + int retval;
> +
> + if (context->runtime_us != OSNOISE_TIME_INIT_VAL)
> + return context->runtime_us;
> +
> + if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_runtime_us;
> +
> + runtime_path = tracefs_get_tracing_file("osnoise/runtime_us");
> +
> + context->runtime_fd = open(runtime_path, O_RDWR);
> + if (context->runtime_fd < 0)
> + goto out_err;
> +
> + retval = read(context->runtime_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +

char *buf;

buf = tracefs_instance_file_read(NULL, "osnoise/runtime_us");

> + runtime_us = get_llong_from_str(buffer);
> + if (runtime_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(runtime_path);
> +
> + context->orig_runtime_us = runtime_us;
> + return runtime_us;
> +
> +out_close:
> + close(context->runtime_fd);

free(buf);

> + context->runtime_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(runtime_path);
> + return 0;
> +}
> +
> +/*
> + * osnoise_get_period - return the original "osnoise/period_us" value
> + *
> + * It also saves the value to be restored.
> + */
> +unsigned long long osnoise_get_period(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + char *period_path;
> + long long period_us;
> + int retval;
> +
> + if (context->period_us != OSNOISE_TIME_INIT_VAL)
> + return context->period_us;
> +
> + if (context->orig_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_period_us;
> +
> + period_path = tracefs_get_tracing_file("osnoise/period_us");
> +

Here too.

> + context->period_fd = open(period_path, O_RDWR);
> + if (context->period_fd < 0)
> + goto out_err;
> +
> + retval = read(context->period_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;
> +
> + period_us = get_llong_from_str(buffer);
> + if (period_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(period_path);
> +
> + context->orig_period_us = period_us;
> + return period_us;
> +
> +out_close:
> + close(context->period_fd);
> + context->period_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(period_path);
> + return 0;
> +}
> +
> +static int __osnoise_write_runtime(struct osnoise_context *context,
> + unsigned long long runtime)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_runtime_us == OSNOISE_TIME_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, sizeof(buffer), "%llu\n", runtime);
> +
> + retval = write(context->runtime_fd, buffer, strlen(buffer) + 1);

Again, how important is it to have the fd?


> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->runtime_us = runtime;
> + return 0;
> +}
> +
> +static int __osnoise_write_period(struct osnoise_context *context,
> + unsigned long long period)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_period_us == OSNOISE_TIME_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, sizeof(buffer), "%llu\n", period);
> +
> + retval = write(context->period_fd, buffer, strlen(buffer) + 1);

Here too?

> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->period_us = period;
> + return 0;
> +}
> +
> +/*
> + * osnoise_set_runtime_period - set osnoise runtime and period
> + *
> + * Osnoise's runtime and period are related as runtime <= period.
> + * Thus, this function saves the original values, and then tries
> + * to set the runtime and period if they are != 0.
> + */
> +int osnoise_set_runtime_period(struct osnoise_context *context,
> + unsigned long long runtime,
> + unsigned long long period)
> +{
> + unsigned long long curr_runtime_us;
> + unsigned long long curr_period_us;
> + int retval;
> +
> + if (!period && !runtime)
> + return 0;
> +
> + curr_runtime_us = osnoise_get_runtime(context);
> + curr_period_us = osnoise_get_period(context);
> +
> + /* error getting any value? */
> + if (curr_period_us == -1 || curr_runtime_us == -1)
> + return -1;
> +
> + if (!period) {
> + if (runtime > curr_period_us)
> + return -1;
> + return __osnoise_write_runtime(context, runtime);
> + } else if (!runtime) {
> + if (period < curr_runtime_us)
> + return -1;
> + return __osnoise_write_period(context, period);
> + }
> +
> + if (runtime > curr_period_us) {
> + retval = __osnoise_write_period(context, period);
> + if (retval)
> + return -1;
> + retval = __osnoise_write_runtime(context, runtime);
> + if (retval)
> + return -1;
> + } else {
> + retval = __osnoise_write_runtime(context, runtime);
> + if (retval)
> + return -1;
> + retval = __osnoise_write_period(context, period);
> + if (retval)
> + return -1;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_runtime_period - restore the original runtime and period
> + */
> +void osnoise_restore_runtime_period(struct osnoise_context *context)
> +{
> + unsigned long long orig_runtime = context->orig_runtime_us;
> + unsigned long long orig_period = context->orig_period_us;
> + unsigned long long curr_runtime = context->runtime_us;
> + unsigned long long curr_period = context->period_us;
> + int retval;
> +
> + if ((orig_runtime == OSNOISE_TIME_INIT_VAL) && (orig_period == OSNOISE_TIME_INIT_VAL))
> + return;
> +
> + if ((orig_period == curr_period) && (orig_runtime == curr_runtime))
> + goto out_done;
> +
> + retval = osnoise_set_runtime_period(context, orig_runtime, orig_period);
> + if (retval)
> + err_msg("Could not restore original osnoise runtime/period\n");
> +
> +out_done:
> + context->runtime_us = OSNOISE_TIME_INIT_VAL;
> + context->period_us = OSNOISE_TIME_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_put_runtime_period - restore original values and cleanup data
> + */
> +void osnoise_put_runtime_period(struct osnoise_context *context)
> +{
> + osnoise_restore_runtime_period(context);
> +
> + if (context->orig_runtime_us != OSNOISE_TIME_INIT_VAL) {
> + close(context->runtime_fd);
> + context->runtime_fd = CLOSED_FD;
> + context->orig_runtime_us = OSNOISE_TIME_INIT_VAL;
> + }
> +
> + if (context->orig_period_us != OSNOISE_TIME_INIT_VAL) {
> + close(context->period_fd);
> + context->period_fd = CLOSED_FD;
> + context->orig_period_us = OSNOISE_TIME_INIT_VAL;
> + }
> +}
> +
> +/*
> + * osnoise_get_timerlat_period_us - read and save the original "timerlat_period_us"
> + */
> +static long long
> +osnoise_get_timerlat_period_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long timerlat_period_us;
> + char *stop_path;
> + int retval;
> +
> + if (context->timerlat_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->timerlat_period_us;
> +
> + if (context->orig_timerlat_period_us != OSNOISE_TIME_INIT_VAL)
> + return context->orig_timerlat_period_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/timerlat_period_us");
> +
> + context->timerlat_period_us_fd = open(stop_path, O_RDWR);
> + if (context->timerlat_period_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->timerlat_period_us_fd, &buffer, sizeof(buffer));

Same here.

> + if (retval <= 0)
> + goto out_close;
> +
> + timerlat_period_us = get_llong_from_str(buffer);
> + if (timerlat_period_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_timerlat_period_us = timerlat_period_us;
> + return timerlat_period_us;
> +
> +out_close:
> + close(context->timerlat_period_us_fd);
> + context->timerlat_period_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;
> +}
> +
> +/*
> + * osnoise_set_timerlat_period_us - set "timerlat_period_us"
> + */
> +int osnoise_set_timerlat_period_us(struct osnoise_context *context, long long timerlat_period_us)
> +{
> + long long curr_timerlat_period_us = osnoise_get_timerlat_period_us(context);
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (curr_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", timerlat_period_us);
> +
> + retval = write(context->timerlat_period_us_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->timerlat_period_us = timerlat_period_us;
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_timerlat_period_us - restore "timerlat_period_us"
> + */
> +void osnoise_restore_timerlat_period_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
> + return;
> +
> + if (context->orig_timerlat_period_us == context->timerlat_period_us)
> + goto out_done;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_timerlat_period_us);
> +
> + retval = write(context->timerlat_period_us_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + err_msg("Could not restore original osnoise timerlat_period_us\n");
> +
> +out_done:
> + context->timerlat_period_us = OSNOISE_TIME_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_put_timerlat_period_us - restore original values and cleanup data
> + */
> +void osnoise_put_timerlat_period_us(struct osnoise_context *context)
> +{
> + osnoise_restore_timerlat_period_us(context);
> +
> + if (context->orig_timerlat_period_us == OSNOISE_TIME_INIT_VAL)
> + return;
> +
> + close(context->timerlat_period_us_fd);
> + context->timerlat_period_us_fd = CLOSED_FD;
> + context->orig_timerlat_period_us = OSNOISE_TIME_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_get_stop_us - read and save the original "stop_tracing_us"
> + */
> +static long long
> +osnoise_get_stop_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long stop_us;
> + char *stop_path;
> + int retval;
> +
> + if (context->stop_us != OSNOISE_OPTION_INIT_VAL)
> + return context->stop_us;
> +
> + if (context->orig_stop_us != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_stop_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_us");
> +
> + context->stop_us_fd = open(stop_path, O_RDWR);
> + if (context->stop_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->stop_us_fd, &buffer, sizeof(buffer));

And here.

> + if (retval <= 0)
> + goto out_close;
> +
> + stop_us = get_llong_from_str(buffer);
> + if (stop_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_stop_us = stop_us;
> + return stop_us;
> +
> +out_close:
> + close(context->stop_us_fd);
> + context->stop_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;
> +}
> +
> +/*
> + * osnoise_set_stop_us - set "stop_tracing_us"
> + */
> +int osnoise_set_stop_us(struct osnoise_context *context, long long stop_us)
> +{
> + long long curr_stop_us = osnoise_get_stop_us(context);
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (curr_stop_us == OSNOISE_OPTION_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", stop_us);
> +
> + retval = write(context->stop_us_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->stop_us = stop_us;
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_stop_us - restore the original "stop_tracing_us"
> + */
> +void osnoise_restore_stop_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + if (context->orig_stop_us == context->stop_us)
> + goto out_done;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_stop_us);
> +
> + retval = write(context->stop_us_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + err_msg("Could not restore original osnoise stop_us\n");
> +
> +out_done:
> + context->stop_us = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_put_stop_us - restore original values and cleanup data
> + */
> +void osnoise_put_stop_us(struct osnoise_context *context)
> +{
> + osnoise_restore_stop_us(context);
> +
> + if (context->orig_stop_us == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + close(context->stop_us_fd);
> + context->stop_us_fd = CLOSED_FD;
> + context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_get_stop_total_us - read and save the original "stop_tracing_total_us"
> + */
> +static long long
> +osnoise_get_stop_total_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long stop_total_us;
> + char *stop_path;
> + int retval;
> +
> + if (context->stop_total_us != OSNOISE_OPTION_INIT_VAL)
> + return context->stop_total_us;
> +
> + if (context->orig_stop_total_us != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_stop_total_us;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/stop_tracing_total_us");
> +
> + context->stop_total_us_fd = open(stop_path, O_RDWR);
> + if (context->stop_total_us_fd < 0)
> + goto out_err;
> +
> + retval = read(context->stop_total_us_fd, &buffer, sizeof(buffer));

And here.

> + if (retval <= 0)
> + goto out_close;
> +
> + stop_total_us = get_llong_from_str(buffer);
> + if (stop_total_us < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_stop_total_us = stop_total_us;
> + return stop_total_us;
> +
> +out_close:
> + close(context->stop_total_us_fd);
> + context->stop_total_us_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;
> +}
> +
> +/*
> + * osnoise_set_stop_total_us - set "stop_tracing_total_us"
> + */
> +int osnoise_set_stop_total_us(struct osnoise_context *context, long long stop_total_us)
> +{
> + long long curr_stop_total_us = osnoise_get_stop_total_us(context);
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (curr_stop_total_us == OSNOISE_OPTION_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", stop_total_us);
> +
> + retval = write(context->stop_total_us_fd, buffer, strlen(buffer) + 1);

And here.

Hmm, we should add a helper:

tracefs_instance_file_printf(instance, fmt, ...)

Where the above could be:

tracefs_instance_file_printf(NULL, "%lld\n", stop_total_us);

Of course, for now, you could just add a helper function that does that.

> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->stop_total_us = stop_total_us;
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_stop_total_us - restore the original "stop_tracing_total_us"
> + */
> +void osnoise_restore_stop_total_us(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + if (context->orig_stop_total_us == context->stop_total_us)
> + goto out_done;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_stop_total_us);
> +
> + retval = write(context->stop_total_us_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + err_msg("Could not restore original osnoise stop_total_us\n");
> +
> +out_done:
> + context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_put_stop_total_us - restore original values and cleanup data
> + */
> +void osnoise_put_stop_total_us(struct osnoise_context *context)
> +{
> + osnoise_restore_stop_total_us(context);
> +
> + if (context->orig_stop_total_us == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + close(context->stop_total_us_fd);
> + context->stop_total_us_fd = CLOSED_FD;
> + context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_get_print_stack - read and save the original "print_stack"
> + */
> +static long long
> +osnoise_get_print_stack(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + long long print_stack;
> + char *stop_path;
> + int retval;
> +
> + if (context->print_stack != OSNOISE_OPTION_INIT_VAL)
> + return context->print_stack;
> +
> + if (context->orig_print_stack != OSNOISE_OPTION_INIT_VAL)
> + return context->orig_print_stack;
> +
> + stop_path = tracefs_get_tracing_file("osnoise/print_stack");
> +
> + context->print_stack_fd = open(stop_path, O_RDWR);
> + if (context->print_stack_fd < 0)
> + goto out_err;
> +
> + retval = read(context->print_stack_fd, &buffer, sizeof(buffer));
> + if (retval <= 0)
> + goto out_close;

And here.

> +
> + print_stack = get_llong_from_str(buffer);
> + if (print_stack < 0)
> + goto out_close;
> +
> + tracefs_put_tracing_file(stop_path);
> +
> + context->orig_print_stack = print_stack;
> + return print_stack;
> +
> +out_close:
> + close(context->print_stack_fd);
> + context->print_stack_fd = CLOSED_FD;
> +out_err:
> + tracefs_put_tracing_file(stop_path);
> + return -1;
> +}
> +
> +/*
> + * osnoise_set_print_stack - set "print_stack"
> + */
> +int osnoise_set_print_stack(struct osnoise_context *context, long long print_stack)
> +{
> + long long curr_print_stack = osnoise_get_print_stack(context);
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (curr_print_stack == OSNOISE_OPTION_INIT_VAL)
> + return -1;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", print_stack);
> +
> + retval = write(context->print_stack_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + return -1;
> +
> + context->print_stack = print_stack;
> +
> + return 0;
> +}
> +
> +/*
> + * osnoise_restore_print_stack - restore the original "print_stack"
> + */
> +void osnoise_restore_print_stack(struct osnoise_context *context)
> +{
> + char buffer[BUFF_U64_STR_SIZE];
> + int retval;
> +
> + if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + if (context->orig_print_stack == context->print_stack)
> + goto out_done;
> +
> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", context->orig_print_stack);
> +
> + retval = write(context->print_stack_fd, buffer, strlen(buffer) + 1);

And here.

> + if (retval < (strlen(buffer) + 1))
> + err_msg("Could not restore original osnoise print_stack\n");
> +
> +out_done:
> + context->print_stack = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * osnoise_put_print_stack - restore original values and cleanup data
> + */
> +void osnoise_put_print_stack(struct osnoise_context *context)
> +{
> + osnoise_restore_print_stack(context);
> +
> + if (context->orig_print_stack == OSNOISE_OPTION_INIT_VAL)
> + return;
> +
> + close(context->print_stack_fd);
> + context->print_stack_fd = CLOSED_FD;
> + context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
> +}
> +
> +/*
> + * enable_osnoise - enable osnoise tracer in the trace_instance
> + */
> +int enable_osnoise(struct trace_instance *trace)
> +{
> + return enable_tracer_by_name(trace->inst, "osnoise");
> +}
> +
> +/*
> + * enable_timerlat - enable timerlat tracer in the trace_instance
> + */
> +int enable_timerlat(struct trace_instance *trace)
> +{
> + return enable_tracer_by_name(trace->inst, "timerlat");
> +}
> +
> +enum {
> + FLAG_CONTEXT_NEWLY_CREATED = (1 << 0),
> + FLAG_CONTEXT_DELETED = (1 << 1),
> +};
> +
> +/*
> + * osnoise_get_context - increase the usage of a context and return it
> + */
> +int osnoise_get_context(struct osnoise_context *context)
> +{
> + int ret;
> +
> + if (context->flags & FLAG_CONTEXT_DELETED) {
> + ret = -1;
> + } else {
> + context->ref++;
> + ret = 0;
> + }
> +
> + return ret;
> +}
> +
> +/*
> + * osnoise_context_alloc - alloc an osnoise_context
> + *
> + * The osnoise context contains the information of the "osnoise/" configs.
> + * It is used to set and restore the config.
> + */
> +struct osnoise_context *osnoise_context_alloc(void)
> +{
> + struct osnoise_context *context;
> +
> + context = calloc(1, sizeof(*context));
> + if (!context)
> + goto out_err;
> +
> + context->cpus_fd = CLOSED_FD;
> + context->runtime_fd = CLOSED_FD;
> + context->period_fd = CLOSED_FD;
> + context->stop_us_fd = CLOSED_FD;
> + context->stop_total_us_fd = CLOSED_FD;
> + context->timerlat_period_us_fd = CLOSED_FD;
> + context->print_stack_fd = CLOSED_FD;

You could save a lot of code by using the tracefs_instance_file_*()
helpers. And do you really need to keep around the file descriptors?

-- Steve


> +
> + context->orig_stop_us = OSNOISE_OPTION_INIT_VAL;
> + context->stop_us = OSNOISE_OPTION_INIT_VAL;
> +
> + context->orig_stop_total_us = OSNOISE_OPTION_INIT_VAL;
> + context->stop_total_us = OSNOISE_OPTION_INIT_VAL;
> +
> + context->orig_print_stack = OSNOISE_OPTION_INIT_VAL;
> + context->print_stack = OSNOISE_OPTION_INIT_VAL;
> +
> + osnoise_get_context(context);
> +
> + return context;
> +out_err:
> + if (context)
> + free(context);
> + return NULL;
> +}
> +
> +/*
> + * osnoise_put_context - put the osnoise_put_context
> + *
> + * If there is no other user for the context, the original data
> + * is restored.
> + */
> +void osnoise_put_context(struct osnoise_context *context)
> +{
> + if (--context->ref < 1)
> + context->flags |= FLAG_CONTEXT_DELETED;
> +
> + if (!(context->flags & FLAG_CONTEXT_DELETED))
> + return;
> +
> + osnoise_put_cpus(context);
> + osnoise_put_runtime_period(context);
> + osnoise_put_stop_us(context);
> + osnoise_put_stop_total_us(context);
> + osnoise_put_timerlat_period_us(context);
> + osnoise_put_print_stack(context);
> +
> + free(context);
> +}
> +
> +/*
> + * osnoise_destroy_tool - disable trace, restore configs and free data
> + */
> +void osnoise_destroy_tool(struct osnoise_tool *top)
> +{
> + trace_instance_destroy(&top->trace);
> +
> + if (top->context)
> + osnoise_put_context(top->context);
> +
> + free(top);
> +}
> +
> +/*
> + * osnoise_init_tool - init an osnoise tool
> + *
> + * It allocs data, create a context to store data and
> + * creates a new trace instance for the tool.
> + */
> +struct osnoise_tool *osnoise_init_tool(char *tool_name)
> +{
> + struct osnoise_tool *top;
> + int retval;
> +
> + top = calloc(1, sizeof(*top));
> + if (!top)
> + return NULL;
> +
> + top->context = osnoise_context_alloc();
> + if (!top->context)
> + goto out_err;
> +
> + retval = trace_instance_init(&top->trace, tool_name);
> + if (retval)
> + goto out_err;
> +
> + return top;
> +out_err:
> + osnoise_destroy_tool(top);
> + return NULL;
> +}
> +
> +/*
> + * osnoise_init_trace_tool - init a tracer instance to trace osnoise events
> + */
> +struct osnoise_tool *osnoise_init_trace_tool(char *tracer)
> +{
> + struct osnoise_tool *trace;
> + int retval;
> +
> + trace = osnoise_init_tool("osnoise_trace");
> + if (!trace)
> + return NULL;
> +
> + retval = tracefs_event_enable(trace->trace.inst, "osnoise", NULL);
> + if (retval < 0 && !errno) {
> + err_msg("Could not find osnoise events\n");
> + goto out_err;
> + }
> +
> + retval = enable_tracer_by_name(trace->trace.inst, tracer);
> + if (retval) {
> + err_msg("Could not enable osnoiser tracer for tracing\n");
> + goto out_err;
> + }
> +
> + return trace;
> +out_err:
> + osnoise_destroy_tool(trace);
> + return NULL;
> +}
> +
> +static void osnoise_usage(void)
> +{
> + int i;
> +
> + static const char *msg[] = {
> + "",
> + "osnoise version " VERSION,
> + "",
> + " usage: [rtla] osnoise [MODE] ...",
> + "",
> + " modes:",
> + " top - prints the summary from osnoise tracer",
> + "",
> + "if no MODE is given, the top mode is called, passing the arguments",
> + NULL,
> + };
> +
> + for (i = 0; msg[i]; i++)
> + fprintf(stderr, "%s\n", msg[i]);
> + exit(1);
> +}
> +
> +int osnoise_main(int argc, char *argv[])
> +{
> + if (argc == 0)
> + goto usage;
> +
> + /*
> + * if osnoise was called without any argument, run the
> + * default cmdline.
> + */
> + if (argc == 1) {
> + osnoise_top_main(argc, argv);
> + exit(0);
> + }
> +
> + if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
> + osnoise_usage();
> + exit(0);
> + } else if (strncmp(argv[1], "-", 1) == 0) {
> + /* the user skipped the tool, call the default one */
> + osnoise_top_main(argc, argv);
> + exit(0);
> + } else if (strcmp(argv[1], "top") == 0) {
> + osnoise_top_main(argc-1, &argv[1]);
> + exit(0);
> + }
> +
> +usage:
> + osnoise_usage();
> + exit(1);
> +}
> diff --git a/tools/tracing/rtla/src/osnoise.h b/tools/tracing/rtla/src/osnoise.h
> new file mode 100644
> index 000000000000..e3e8f8359d99
> --- /dev/null
> +++ b/tools/tracing/rtla/src/osnoise.h
> @@ -0,0 +1,95 @@
> +// SPDX-License-Identifier: GPL-2.0
> +#include "trace.h"
> +
> +/*
> + * osnoise_context - read, store, write, restore osnoise configs.
> + */
> +struct osnoise_context {
> + int flags;
> + int ref;
> +
> + int cpus_fd;
> + int runtime_fd;
> + int period_fd;
> + int stop_us_fd;
> + int stop_total_us_fd;
> + int timerlat_period_us_fd;
> + int print_stack_fd;
> +
> + char *curr_cpus;
> + char *orig_cpus;
> +
> + /* 0 as init value */
> + unsigned long long orig_runtime_us;
> + unsigned long long runtime_us;
> +
> + /* 0 as init value */
> + unsigned long long orig_period_us;
> + unsigned long long period_us;
> +
> + /* 0 as init value */
> + long long orig_timerlat_period_us;
> + long long timerlat_period_us;
> +
> + /* -1 as init value because 0 is disabled */
> + long long orig_stop_us;
> + long long stop_us;
> +
> + /* -1 as init value because 0 is disabled */
> + long long orig_stop_total_us;
> + long long stop_total_us;
> +
> + /* -1 as init value because 0 is disabled */
> + long long orig_print_stack;
> + long long print_stack;
> +};
> +
> +#define CLOSED_FD (-1)
> +#define OSNOISE_OPTION_INIT_VAL (-1)
> +#define OSNOISE_TIME_INIT_VAL (0)
> +
> +struct osnoise_context *osnoise_context_alloc(void);
> +int osnoise_get_context(struct osnoise_context *context);
> +void osnoise_put_context(struct osnoise_context *context);
> +
> +int osnoise_set_cpus(struct osnoise_context *context, char *cpus);
> +void osnoise_restore_cpus(struct osnoise_context *context);
> +
> +int osnoise_set_runtime_period(struct osnoise_context *context,
> + unsigned long long runtime,
> + unsigned long long period);
> +void osnoise_restore_runtime_period(struct osnoise_context *context);
> +
> +int osnoise_set_stop_us(struct osnoise_context *context,
> + long long stop_us);
> +void osnoise_restore_stop_us(struct osnoise_context *context);
> +
> +int osnoise_set_stop_total_us(struct osnoise_context *context,
> + long long stop_total_us);
> +void osnoise_restore_stop_total_us(struct osnoise_context *context);
> +
> +int osnoise_set_timerlat_period_us(struct osnoise_context *context,
> + long long timerlat_period_us);
> +void osnoise_restore_timerlat_period_us(struct osnoise_context *context);
> +
> +void osnoise_restore_print_stack(struct osnoise_context *context);
> +int osnoise_set_print_stack(struct osnoise_context *context,
> + long long print_stack);
> +
> +/*
> + * osnoise_tool - osnoise based tool definition.
> + */
> +struct osnoise_tool {
> + struct trace_instance trace;
> + struct osnoise_context *context;
> + void *data;
> + void *params;
> + time_t start_time;
> +};
> +
> +void osnoise_destroy_tool(struct osnoise_tool *top);
> +struct osnoise_tool *osnoise_init_tool(char *tool_name);
> +struct osnoise_tool *osnoise_init_trace_tool(char *tracer);
> +
> +int osnoise_top_main(int argc, char **argv);
> +int osnoise_main(int argc, char **argv);
> diff --git a/tools/tracing/rtla/src/rtla.c b/tools/tracing/rtla/src/rtla.c
> index 5ae2664ed47d..669b9750b3b3 100644
> --- a/tools/tracing/rtla/src/rtla.c
> +++ b/tools/tracing/rtla/src/rtla.c
> @@ -8,6 +8,8 @@
> #include <string.h>
> #include <stdio.h>
>
> +#include "osnoise.h"
> +
> /*
> * rtla_usage - print rtla usage
> */
> @@ -22,6 +24,7 @@ static void rtla_usage(void)
> " usage: rtla COMMAND ...",
> "",
> " commands:",
> + " osnoise - gives information about the operating system noise (osnoise)",
> "",
> NULL,
> };
> @@ -39,7 +42,14 @@ static void rtla_usage(void)
> */
> int run_command(int argc, char **argv, int start_position)
> {
> + if (strcmp(argv[start_position], "osnoise") == 0) {
> + osnoise_main(argc-start_position, &argv[start_position]);
> + goto ran;
> + }
> +
> return 0;
> +ran:
> + return 1;
> }
>
> int main(int argc, char *argv[])


2021-12-08 22:14:13

by Steven Rostedt

[permalink] [raw]
Subject: Re: [PATCH V8 03/14] rtla: Add osnoise tool

On Thu, 2 Dec 2021 16:18:53 +0100
Daniel Bristot de Oliveira <[email protected]> wrote:

> >> + if (!strcmp(context->orig_cpus, context->curr_cpus))
> >> + goto out_done;
> >> +
> >> + retval = write(context->cpus_fd, context->orig_cpus, strlen(context->orig_cpus));
> >
> > 'strlen(context->orig_cpus) + 1' for write size;
> >
> >> + if (retval < strlen(context->orig_cpus))
> >
> > Same here. Check 'strlen(context->orig_cpus) + 1'
>
> Fixed in v9.

And if you used the tracefs_instance_file_write() function, you would not
have had his bug ;-)

-- Steve

Subject: Re: [PATCH V8 03/14] rtla: Add osnoise tool

On 12/8/21 23:13, Steven Rostedt wrote:
> On Mon, 29 Nov 2021 12:07:41 +0100
> Daniel Bristot de Oliveira <[email protected]> wrote:
>
>> The osnoise tool is the interface for the osnoise tracer. The osnoise
>> tool will have multiple "modes" with different outputs. At this point,
>> no mode is included.
>>
>> The osnoise.c includes the osnoise_context abstraction. It serves to
>> read-save-change-restore the default values from tracing/osnoise/
>> directory. When the context is deleted, the default values are restored.
>>
>> It also includes some other helper functions for managing osnoise
>> tracer sessions.
>>
>> With these bits and pieces in place, we can start adding some
>> functionality to rtla.
>>
>> Cc: Steven Rostedt <[email protected]>
>> Cc: Ingo Molnar <[email protected]>
>> Cc: Tom Zanussi <[email protected]>
>> Cc: Masami Hiramatsu <[email protected]>
>> Cc: Juri Lelli <[email protected]>
>> Cc: Clark Williams <[email protected]>
>> Cc: John Kacur <[email protected]>
>> Cc: Peter Zijlstra <[email protected]>
>> Cc: Thomas Gleixner <[email protected]>
>> Cc: Sebastian Andrzej Siewior <[email protected]>
>> Cc: Daniel Bristot de Oliveira <[email protected]>
>> Cc: [email protected]
>> Cc: [email protected]
>> Cc: [email protected]
>> Signed-off-by: Daniel Bristot de Oliveira <[email protected]>
>> ---
>> tools/tracing/rtla/Makefile | 2 +
>> tools/tracing/rtla/src/osnoise.c | 1013 ++++++++++++++++++++++++++++++
>> tools/tracing/rtla/src/osnoise.h | 95 +++
>> tools/tracing/rtla/src/rtla.c | 10 +
>> 4 files changed, 1120 insertions(+)
>> create mode 100644 tools/tracing/rtla/src/osnoise.c
>> create mode 100644 tools/tracing/rtla/src/osnoise.h
>>
>> diff --git a/tools/tracing/rtla/Makefile b/tools/tracing/rtla/Makefile
>> index d99ea2d8b87e..ba6f327e815a 100644
>> --- a/tools/tracing/rtla/Makefile
>> +++ b/tools/tracing/rtla/Makefile
>> @@ -60,6 +60,8 @@ install:
>> $(INSTALL) -d -m 755 $(DESTDIR)$(BINDIR)
>> $(INSTALL) rtla -m 755 $(DESTDIR)$(BINDIR)
>> $(STRIP) $(DESTDIR)$(BINDIR)/rtla
>> + @test ! -f $(DESTDIR)$(BINDIR)/osnoise || rm $(DESTDIR)$(BINDIR)/osnoise
>> + ln -s $(DESTDIR)$(BINDIR)/rtla $(DESTDIR)$(BINDIR)/osnoise
>>
>> .PHONY: clean tarball
>> clean:
>> diff --git a/tools/tracing/rtla/src/osnoise.c b/tools/tracing/rtla/src/osnoise.c
>> new file mode 100644
>> index 000000000000..7ef686dddc09
>> --- /dev/null
>> +++ b/tools/tracing/rtla/src/osnoise.c
>> @@ -0,0 +1,1013 @@
>> +// SPDX-License-Identifier: GPL-2.0
>> +/*
>> + * Copyright (C) 2021 Red Hat Inc, Daniel Bristot de Oliveira <[email protected]>
>> + */
>> +
>> +#include <sys/types.h>
>> +#include <sys/stat.h>
>> +#include <pthread.h>
>> +#include <stdlib.h>
>> +#include <string.h>
>> +#include <unistd.h>
>> +#include <errno.h>
>> +#include <fcntl.h>
>> +#include <stdio.h>
>> +
>> +#include "osnoise.h"
>> +#include "utils.h"
>> +
>> +/*
>> + * osnoise_get_cpus - return the original "osnoise/cpus" content
>> + *
>> + * It also saves the value to be restored.
>> + */
>> +char *osnoise_get_cpus(struct osnoise_context *context)
>> +{
>> + char buffer[1024];
>> + char *cpus_path;
>> + int retval;
>> +
>> + if (context->curr_cpus)
>> + return context->curr_cpus;
>> +
>> + if (context->orig_cpus)
>> + return context->orig_cpus;
>> +
>> + cpus_path = tracefs_get_tracing_file("osnoise/cpus");
>> +
>> + context->cpus_fd = open(cpus_path, O_RDWR);
>> + if (context->cpus_fd < 0)
>> + goto out_err;
>> +
>> + retval = read(context->cpus_fd, &buffer, sizeof(buffer));
>> + if (retval <= 0)
>> + goto out_close;
>> +
>> + context->orig_cpus = strdup(buffer);
>
>
> Or you could have done:
>
> context->orig_cpus = tracefs_instance_read(NULL, "osnoise/cpus");


Yep, that would be better.

> as I doubt that reading and writing the cpus file you really care about
> keeping around the file descriptor.

Yep, I do not necessarly need it.... (do not ask me why I am not using, it is
obviosly better... I might have just missed it).

It's not something likely to be done
> where you care about "disrupting" the system. But if you really do care:
>
> context->cpus_fd = tracefs_instance_file_open(NULL, "osnoise/cpus",
> O_RDWR);

I will use tracefs helpers to read/write files, and remove the file descriptor
variables.

[...]

>> + snprintf(buffer, sizeof(buffer), "%llu\n", runtime);
>> +
>> + retval = write(context->runtime_fd, buffer, strlen(buffer) + 1);
>
> Again, how important is it to have the fd?
>

it is not...

[...]

>> +/*
>> + * osnoise_set_stop_total_us - set "stop_tracing_total_us"
>> + */
>> +int osnoise_set_stop_total_us(struct osnoise_context *context, long long stop_total_us)
>> +{
>> + long long curr_stop_total_us = osnoise_get_stop_total_us(context);
>> + char buffer[BUFF_U64_STR_SIZE];
>> + int retval;
>> +
>> + if (curr_stop_total_us == OSNOISE_OPTION_INIT_VAL)
>> + return -1;
>> +
>> + snprintf(buffer, BUFF_U64_STR_SIZE, "%lld\n", stop_total_us);
>> +
>> + retval = write(context->stop_total_us_fd, buffer, strlen(buffer) + 1);
>
> And here.
>
> Hmm, we should add a helper:
>
> tracefs_instance_file_printf(instance, fmt, ...)
>
> Where the above could be:
>
> tracefs_instance_file_printf(NULL, "%lld\n", stop_total_us);
>
> Of course, for now, you could just add a helper function that does that.

sounds good to me.

[...]
>> +/*
>> + * osnoise_context_alloc - alloc an osnoise_context
>> + *
>> + * The osnoise context contains the information of the "osnoise/" configs.
>> + * It is used to set and restore the config.
>> + */
>> +struct osnoise_context *osnoise_context_alloc(void)
>> +{
>> + struct osnoise_context *context;
>> +
>> + context = calloc(1, sizeof(*context));
>> + if (!context)
>> + goto out_err;
>> +
>> + context->cpus_fd = CLOSED_FD;
>> + context->runtime_fd = CLOSED_FD;
>> + context->period_fd = CLOSED_FD;
>> + context->stop_us_fd = CLOSED_FD;
>> + context->stop_total_us_fd = CLOSED_FD;
>> + context->timerlat_period_us_fd = CLOSED_FD;
>> + context->print_stack_fd = CLOSED_FD;
>
> You could save a lot of code by using the tracefs_instance_file_*()
> helpers. And do you really need to keep around the file descriptors?

I will use the helpers in v9, I am convincede... :-)

Thanks Steve
-- Daniel