Merge tag 'trace-tools-v6.14' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...

Pull rv and tools/rtla updates from Steven Rostedt:

 - Add a test suite to test the tool

   Add a small test suite that can be used to test rtla's basic features
   to at least have something to test when applying changes.

 - Automate manual steps in monitor creation

   While creating a new monitor in RV, besides generating code from
   dot2k, there are a few manual steps which can be tedious and error
   prone, like adding the tracepoints, makefile lines and kconfig, or
   selecting events that start the monitor in the initial state.

   Updates were made to try and automate as much as possible among those
   steps to make creating a new RV monitor much quicker. It is still
   requires to select proper tracepoints, this step is harder to
   automate in a general way and, in several cases, would still need
   user intervention.

 - Have rtla timerlat hist and top set OSNOISE_WORKLOAD flag

   Have both rtla-timerlat-hist and rtla-timerlat-top set
   OSNOISE_WORKLOAD to the proper value ("on" when running with -k,
   "off" when running with -u) every time the option is available
   instead of setting it only when running with -u.

   This prevents rtla timerlat -k from giving no results when
   NO_OSNOISE_WORKLOAD is set, either manually or by an abnormally
   exited earlier run of rtla timerlat -u.

 - Stop rtla timerlat on signal properly when overloaded

   There is an issue where if rtla is run on machines with a high number
   of CPUs (100+), timerlat can generate more samples than rtla is able
   to process via tracefs_iterate_raw_events. This is especially common
   when the interval is set to 100us (rteval and cyclictest default) as
   opposed to the rtla default of 1000us, but also happens with the rtla
   default.

   Currently, this leads to rtla hanging and having to be terminated
   with SIGTERM. SIGINT setting stop_tracing is not enough, since more
   and more events are coming and tracefs_iterate_raw_events never
   exits.

   To fix this: Stop the timerlat tracer on SIGINT/SIGALRM to ensure no
   more events are generated when rtla is supposed to exit.

   Also on receiving SIGINT/SIGALRM twice, abort iteration immediately
   with tracefs_iterate_stop, making rtla exit right away instead of
   waiting for all events to be processed.

 - Account for missed events

   Due to tracefs buffer overflow, it can happen that rtla misses
   events, making the tracing results inaccurate.

   Count both the number of missed events and the total number of
   processed events, and display missed events as well as their
   percentage. The numbers are displayed for both osnoise and timerlat,
   even though for the earlier, missed events are generally not
   expected.

   For hist, the number is displayed at the end of the run; for top, it
   is displayed on each printing of the top table.

 - Changes to make osnoise more robust

   There was a dependency in the code that the first field of the
   osnoise_tool structure was the trace field. If that that ever
   changed, then the code work break. Change the code to encapsulate
   this dependency where the code that uses the structure does not have
   this dependency.

* tag 'trace-tools-v6.14' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace: (22 commits)
  rtla: Report missed event count
  rtla: Add function to report missed events
  rtla: Count all processed events
  rtla: Count missed trace events
  tools/rtla: Add osnoise_trace_is_off()
  rtla/timerlat_top: Set OSNOISE_WORKLOAD for kernel threads
  rtla/timerlat_hist: Set OSNOISE_WORKLOAD for kernel threads
  rtla/osnoise: Distinguish missing workload option
  rtla/timerlat_top: Abort event processing on second signal
  rtla/timerlat_hist: Abort event processing on second signal
  rtla/timerlat_top: Stop timerlat tracer on signal
  rtla/timerlat_hist: Stop timerlat tracer on signal
  rtla: Add trace_instance_stop
  tools/rtla: Add basic test suite
  verification/dot2k: Implement event type detection
  verification/dot2k: Auto patch current kernel source
  verification/dot2k: Simplify manual steps in monitor creation
  rv: Simplify manual steps in monitor creation
  verification/dot2k: Add support for name and description options
  verification/dot2k: More robust template variables
  ...

diff --combined tools/tracing/rtla/src/timerlat_hist.c
index 4403cc4eba302a807d9d1b29febcf698ae509fa7,cdecc8f120dca07c7a146d62feaa1828a7ad9bc4..6d7d0a2d45b47363325d1d75f1b3ca83e560c5ab
--- 1/tools/tracing/rtla/src/timerlat_hist.c
--- 2/tools/tracing/rtla/src/timerlat_hist.c
+++ b/tools/tracing/rtla/src/timerlat_hist.c
@@@ -281,21 -281,6 +281,21 @@@ static void timerlat_hist_header(struc
        trace_seq_reset(s);
  }
  
 +/*
 + * format_summary_value - format a line of summary value (min, max or avg)
 + * of hist data
 + */
 +static void format_summary_value(struct trace_seq *seq,
 +                               int count,
 +                               unsigned long long val,
 +                               bool avg)
 +{
 +      if (count)
 +              trace_seq_printf(seq, "%9llu ", avg ? val / count : val);
 +      else
 +              trace_seq_printf(seq, "%9c ", '-');
 +}
 +
  /*
   * timerlat_print_summary - print the summary of the hist data to the output
   */
@@@ -343,23 -328,29 +343,23 @@@ timerlat_print_summary(struct timerlat_
                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].min_irq);
 -                      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].min_thread);
 -                      else
 -                              trace_seq_printf(trace->seq, "        - ");
 -              }
 -
 -              if (params->user_hist) {
 -                      if (data->hist[cpu].user_count)
 -                              trace_seq_printf(trace->seq, "%9llu ",
 -                                              data->hist[cpu].min_user);
 -                      else
 -                              trace_seq_printf(trace->seq, "        - ");
 -              }
 +              if (!params->no_irq)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].irq_count,
 +                                           data->hist[cpu].min_irq,
 +                                           false);
 +
 +              if (!params->no_thread)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].thread_count,
 +                                           data->hist[cpu].min_thread,
 +                                           false);
 +
 +              if (params->user_hist)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].user_count,
 +                                           data->hist[cpu].min_user,
 +                                           false);
        }
        trace_seq_printf(trace->seq, "\n");
  
@@@ -373,23 -364,29 +373,23 @@@
                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, "        - ");
 -              }
 -
 -              if (params->user_hist) {
 -                      if (data->hist[cpu].user_count)
 -                              trace_seq_printf(trace->seq, "%9llu ",
 -                                               data->hist[cpu].sum_user / data->hist[cpu].user_count);
 -                      else
 -                              trace_seq_printf(trace->seq, "        - ");
 -              }
 +              if (!params->no_irq)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].irq_count,
 +                                           data->hist[cpu].sum_irq,
 +                                           true);
 +
 +              if (!params->no_thread)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].thread_count,
 +                                           data->hist[cpu].sum_thread,
 +                                           true);
 +
 +              if (params->user_hist)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].user_count,
 +                                           data->hist[cpu].sum_user,
 +                                           true);
        }
        trace_seq_printf(trace->seq, "\n");
  
@@@ -403,23 -400,29 +403,23 @@@
                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].max_irq);
 -                      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].max_thread);
 -                      else
 -                              trace_seq_printf(trace->seq, "        - ");
 -              }
 -
 -              if (params->user_hist) {
 -                      if (data->hist[cpu].user_count)
 -                              trace_seq_printf(trace->seq, "%9llu ",
 -                                              data->hist[cpu].max_user);
 -                      else
 -                              trace_seq_printf(trace->seq, "        - ");
 -              }
 +              if (!params->no_irq)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].irq_count,
 +                                           data->hist[cpu].max_irq,
 +                                           false);
 +
 +              if (!params->no_thread)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].thread_count,
 +                                           data->hist[cpu].max_thread,
 +                                           false);
 +
 +              if (params->user_hist)
 +                      format_summary_value(trace->seq,
 +                                           data->hist[cpu].user_count,
 +                                           data->hist[cpu].max_user,
 +                                           false);
        }
        trace_seq_printf(trace->seq, "\n");
        trace_seq_do_printf(trace->seq);
@@@ -503,22 -506,16 +503,22 @@@ timerlat_print_stats_all(struct timerla
                trace_seq_printf(trace->seq, "min:  ");
  
        if (!params->no_irq)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.min_irq);
 +              format_summary_value(trace->seq,
 +                                   sum.irq_count,
 +                                   sum.min_irq,
 +                                   false);
  
        if (!params->no_thread)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.min_thread);
 +              format_summary_value(trace->seq,
 +                                   sum.thread_count,
 +                                   sum.min_thread,
 +                                   false);
  
        if (params->user_hist)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.min_user);
 +              format_summary_value(trace->seq,
 +                                   sum.user_count,
 +                                   sum.min_user,
 +                                   false);
  
        trace_seq_printf(trace->seq, "\n");
  
@@@ -526,22 -523,16 +526,22 @@@
                trace_seq_printf(trace->seq, "avg:  ");
  
        if (!params->no_irq)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.sum_irq / sum.irq_count);
 +              format_summary_value(trace->seq,
 +                                   sum.irq_count,
 +                                   sum.sum_irq,
 +                                   true);
  
        if (!params->no_thread)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.sum_thread / sum.thread_count);
 +              format_summary_value(trace->seq,
 +                                   sum.thread_count,
 +                                   sum.sum_thread,
 +                                   true);
  
        if (params->user_hist)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.sum_user / sum.user_count);
 +              format_summary_value(trace->seq,
 +                                   sum.user_count,
 +                                   sum.sum_user,
 +                                   true);
  
        trace_seq_printf(trace->seq, "\n");
  
@@@ -549,22 -540,16 +549,22 @@@
                trace_seq_printf(trace->seq, "max:  ");
  
        if (!params->no_irq)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.max_irq);
 +              format_summary_value(trace->seq,
 +                                   sum.irq_count,
 +                                   sum.max_irq,
 +                                   false);
  
        if (!params->no_thread)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.max_thread);
 +              format_summary_value(trace->seq,
 +                                   sum.thread_count,
 +                                   sum.max_thread,
 +                                   false);
  
        if (params->user_hist)
 -              trace_seq_printf(trace->seq, "%9llu ",
 -                               sum.max_user);
 +              format_summary_value(trace->seq,
 +                                   sum.user_count,
 +                                   sum.max_user,
 +                                   false);
  
        trace_seq_printf(trace->seq, "\n");
        trace_seq_do_printf(trace->seq);
@@@ -656,6 -641,7 +656,7 @@@ timerlat_print_stats(struct timerlat_hi
  
        timerlat_print_summary(params, trace, data);
        timerlat_print_stats_all(params, trace, data);
+       osnoise_report_missed_events(tool);
  }
  
  /*
@@@ -1100,12 -1086,15 +1101,15 @@@ timerlat_hist_apply_config(struct osnoi
                }
        }
  
-       if (params->user_hist) {
-               retval = osnoise_set_workload(tool->context, 0);
-               if (retval) {
-                       err_msg("Failed to set OSNOISE_WORKLOAD option\n");
-                       goto out_err;
-               }
+       /*
+       * Set workload according to type of thread if the kernel supports it.
+       * On kernels without support, user threads will have already failed
+       * on missing timerlat_fd, and kernel threads do not need it.
+       */
+       retval = osnoise_set_workload(tool->context, params->kernel_workload);
+       if (retval < -1) {
+               err_msg("Failed to set OSNOISE_WORKLOAD option\n");
+               goto out_err;
        }
  
        return 0;
@@@ -1146,9 -1135,20 +1150,20 @@@ out_err
  }
  
  static int stop_tracing;
+ static struct trace_instance *hist_inst = NULL;
  static void stop_hist(int sig)
  {
+       if (stop_tracing) {
+               /*
+                * Stop requested twice in a row; abort event processing and
+                * exit immediately
+                */
+               tracefs_iterate_stop(hist_inst->inst);
+               return;
+       }
        stop_tracing = 1;
+       if (hist_inst)
+               trace_instance_stop(hist_inst);
  }
  
  /*
@@@ -1195,6 -1195,12 +1210,12 @@@ int timerlat_hist_main(int argc, char *
        }
  
        trace = &tool->trace;
+       /*
+        * Save trace instance into global variable so that SIGINT can stop
+        * the timerlat tracer.
+        * Otherwise, rtla could loop indefinitely when overloaded.
+        */
+       hist_inst = trace;
  
        retval = enable_timerlat(trace);
        if (retval) {
@@@ -1342,7 -1348,7 +1363,7 @@@
                        goto out_hist;
                }
  
-               if (trace_is_off(&tool->trace, &record->trace))
+               if (osnoise_trace_is_off(tool, record))
                        break;
  
                /* is there still any user-threads ? */
@@@ -1363,7 -1369,7 +1384,7 @@@
  
        return_value = 0;
  
-       if (trace_is_off(&tool->trace, &record->trace)) {
+       if (osnoise_trace_is_off(tool, record) && !stop_tracing) {
                printf("rtla timerlat hit stop tracing\n");
  
                if (!params->no_aa)