Merge branch 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf updates from Ingo Molnar:
 "Kernel side changes:

   - Clean up the x86 instruction decoder (Masami Hiramatsu)

   - Add new uprobes optimization for PUSH instructions on x86 (Yonghong
     Song)

   - Add MSR_IA32_THERM_STATUS to the MSR events (Stephane Eranian)

   - Fix misc bugs, update documentation, plus various cleanups (Jiri
     Olsa)

  There's a large number of tooling side improvements:

   - Intel-PT/BTS improvements (Adrian Hunter)

   - Numerous 'perf trace' improvements (Arnaldo Carvalho de Melo)

   - Introduce an errno code to string facility (Hendrik Brueckner)

   - Various build system improvements (Jiri Olsa)

   - Add support for CoreSight trace decoding by making the perf tools
     use the external openCSD (Mathieu Poirier, Tor Jeremiassen)

   - Add ARM Statistical Profiling Extensions (SPE) support (Kim
     Phillips)

   - libtraceevent updates (Steven Rostedt)

   - Intel vendor event JSON updates (Andi Kleen)

   - Introduce 'perf report --mmaps' and 'perf report --tasks' to show
     info present in 'perf.data' (Jiri Olsa, Arnaldo Carvalho de Melo)

   - Add infrastructure to record first and last sample time to the
     perf.data file header, so that when processing all samples in a
     'perf record' session, such as when doing build-id processing, or
     when specifically requesting that that info be recorded, use that
     in 'perf report --time', that also got support for percent slices
     in addition to absolute ones.

     I.e. now it is possible to ask for the samples in the 10%-20% time
     slice of a perf.data file (Jin Yao)

   - Allow system wide 'perf stat --per-thread', sorting the result (Jin
     Yao)

     E.g.:

      [root@jouet ~]# perf stat --per-thread --metrics IPC
      ^C
       Performance counter stats for 'system wide':

                  make-22229  23,012,094,032  inst_retired.any   #  0.8 IPC
                   cc1-22419     692,027,497  inst_retired.any   #  0.8 IPC
                   gcc-22418     328,231,855  inst_retired.any   #  0.9 IPC
                   cc1-22509     220,853,647  inst_retired.any   #  0.8 IPC
                   gcc-22486     199,874,810  inst_retired.any   #  1.0 IPC
                    as-22466     177,896,365  inst_retired.any   #  0.9 IPC
                   cc1-22465     150,732,374  inst_retired.any   #  0.8 IPC
                   gcc-22508     112,555,593  inst_retired.any   #  0.9 IPC
                   cc1-22487     108,964,079  inst_retired.any   #  0.7 IPC
       qemu-system-x86-2697       21,330,550  inst_retired.any   #  0.3 IPC
       systemd-journal-551        20,642,951  inst_retired.any   #  0.4 IPC
       docker-containe-17651       9,552,892  inst_retired.any   #  0.5 IPC
       dockerd-current-9809        7,528,586  inst_retired.any   #  0.5 IPC
                  make-22153  12,504,194,380  inst_retired.any   #  0.8 IPC
               python2-22429  12,081,290,954  inst_retired.any   #  0.8 IPC
      <SNIP>
               python2-22429  15,026,328,103  cpu_clk_unhalted.thread
                   cc1-22419     826,660,193  cpu_clk_unhalted.thread
                   gcc-22418     365,321,295  cpu_clk_unhalted.thread
                   cc1-22509     279,169,362  cpu_clk_unhalted.thread
                   gcc-22486     210,156,950  cpu_clk_unhalted.thread
      <SNIP>

           5.638075538 seconds time elapsed

     [root@jouet ~]#

   - Improve shell auto-completion of perf events (Jin Yao)

   - 'perf probe' improvements (Masami Hiramatsu)

   - Improve PMU infrastructure to support amp64's ThunderX2
     implementation defined core events (Ganapatrao Kulkarni)

   - Various annotation related improvements and fixes (Thomas Richter)

   - Clarify usage of 'overwrite' and 'backward' in the evlist/mmap
     code, removing the 'overwrite' parameter from several functions as
     it was always used it as 'false' (Wang Nan)

   - Fix/improve 'perf record' reverse recording support (Wang Nan)

   - Improve command line options documentation (Sihyeon Jang)

   - Optimize sample parsing for ordering events, where we don't need to
     parse all the PERF_SAMPLE_ bits, just the ones leading to the
     timestamp needed to reorder events (Jiri Olsa)

   - Generalize the annotation code to support other source information
     besides objdump/DWARF obtained ones, starting with python scripts,
     that will is slated to be merged soon (Jiri Olsa)

   - ... and a lot more that I failed to list, see the shortlog and
     changelog for details"

* 'perf-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (262 commits)
  perf trace beauty flock: Move to separate object file
  perf evlist: Remove fcntl.h from evlist.h
  perf trace beauty futex: Beautify FUTEX_BITSET_MATCH_ANY
  perf trace: Do not print from time delta for interrupted syscall lines
  perf trace: Add --print-sample
  perf bpf: Remove misplaced __maybe_unused attribute
  MAINTAINERS: Adding entry for CoreSight trace decoding
  perf tools: Add mechanic to synthesise CoreSight trace packets
  perf tools: Add full support for CoreSight trace decoding
  pert tools: Add queue management functionality
  perf tools: Add functionality to communicate with the openCSD decoder
  perf tools: Add support for decoding CoreSight trace data
  perf tools: Add decoder mechanic to support dumping trace data
  perf tools: Add processing of coresight metadata
  perf tools: Add initial entry point for decoder CoreSight traces
  perf tools: Integrating the CoreSight decoding library
  perf vendor events intel: Update IvyTown files to V20
  perf vendor events intel: Update IvyBridge files to V20
  perf vendor events intel: Update BroadwellDE events to V7
  perf vendor events intel: Update SkylakeX events to V1.06
  ...

1 files changed, 289 insertions, 12 deletions

diff --git a/tools/perf/util/time-utils.c b/tools/perf/util/time-utils.c
index 81927d027417..6193b46050a5 100644
--- a/tools/perf/util/time-utils.c
+++ b/tools/perf/util/time-utils.c
@@ -6,6 +6,7 @@
 #include <time.h>
 #include <errno.h>
 #include <inttypes.h>
+#include <math.h>
 
 #include "perf.h"
 #include "debug.h"
@@ -60,11 +61,10 @@ static int parse_timestr_sec_nsec(struct perf_time_interval *ptime,
         return 0;
 }
 
-int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
+static int split_start_end(char **start, char **end, const char *ostr, char ch)
 {
         char *start_str, *end_str;
         char *d, *str;
-        int rc = 0;
 
         if (ostr == NULL || *ostr == '\0')
                 return 0;
@@ -74,25 +74,35 @@ int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
         if (str == NULL)
                 return -ENOMEM;
 
-        ptime->start = 0;
-        ptime->end = 0;
-
-        /* str has the format: <start>,<stop>
-         * variations: <start>,
-         *             ,<stop>
-         *             ,
-         */
         start_str = str;
-        d = strchr(start_str, ',');
+        d = strchr(start_str, ch);
         if (d) {
                 *d = '\0';
                 ++d;
         }
         end_str = d;
 
+        *start = start_str;
+        *end = end_str;
+
+        return 0;
+}
+
+int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
+{
+        char *start_str = NULL, *end_str;
+        int rc;
+
+        rc = split_start_end(&start_str, &end_str, ostr, ',');
+        if (rc || !start_str)
+                return rc;
+
+        ptime->start = 0;
+        ptime->end = 0;
+
         rc = parse_timestr_sec_nsec(ptime, start_str, end_str);
 
-        free(str);
+        free(start_str);
 
         /* make sure end time is after start time if it was given */
         if (rc == 0 && ptime->end && ptime->end < ptime->start)
@@ -104,6 +114,245 @@ int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
         return rc;
 }
 
+static int parse_percent(double *pcnt, char *str)
+{
+        char *c, *endptr;
+        double d;
+
+        c = strchr(str, '%');
+        if (c)
+                *c = '\0';
+        else
+                return -1;
+
+        d = strtod(str, &endptr);
+        if (endptr != str + strlen(str))
+                return -1;
+
+        *pcnt = d / 100.0;
+        return 0;
+}
+
+static int percent_slash_split(char *str, struct perf_time_interval *ptime,
+                               u64 start, u64 end)
+{
+        char *p, *end_str;
+        double pcnt, start_pcnt, end_pcnt;
+        u64 total = end - start;
+        int i;
+
+        /*
+         * Example:
+         * 10%/2: select the second 10% slice and the third 10% slice
+         */
+
+        /* We can modify this string since the original one is copied */
+        p = strchr(str, '/');
+        if (!p)
+                return -1;
+
+        *p = '\0';
+        if (parse_percent(&pcnt, str) < 0)
+                return -1;
+
+        p++;
+        i = (int)strtol(p, &end_str, 10);
+        if (*end_str)
+                return -1;
+
+        if (pcnt <= 0.0)
+                return -1;
+
+        start_pcnt = pcnt * (i - 1);
+        end_pcnt = pcnt * i;
+
+        if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
+            end_pcnt < 0.0 || end_pcnt > 1.0) {
+                return -1;
+        }
+
+        ptime->start = start + round(start_pcnt * total);
+        ptime->end = start + round(end_pcnt * total);
+
+        return 0;
+}
+
+static int percent_dash_split(char *str, struct perf_time_interval *ptime,
+                              u64 start, u64 end)
+{
+        char *start_str = NULL, *end_str;
+        double start_pcnt, end_pcnt;
+        u64 total = end - start;
+        int ret;
+
+        /*
+         * Example: 0%-10%
+         */
+
+        ret = split_start_end(&start_str, &end_str, str, '-');
+        if (ret || !start_str)
+                return ret;
+
+        if ((parse_percent(&start_pcnt, start_str) != 0) ||
+            (parse_percent(&end_pcnt, end_str) != 0)) {
+                free(start_str);
+                return -1;
+        }
+
+        free(start_str);
+
+        if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
+            end_pcnt < 0.0 || end_pcnt > 1.0 ||
+            start_pcnt > end_pcnt) {
+                return -1;
+        }
+
+        ptime->start = start + round(start_pcnt * total);
+        ptime->end = start + round(end_pcnt * total);
+
+        return 0;
+}
+
+typedef int (*time_pecent_split)(char *, struct perf_time_interval *,
+                                 u64 start, u64 end);
+
+static int percent_comma_split(struct perf_time_interval *ptime_buf, int num,
+                               const char *ostr, u64 start, u64 end,
+                               time_pecent_split func)
+{
+        char *str, *p1, *p2;
+        int len, ret, i = 0;
+
+        str = strdup(ostr);
+        if (str == NULL)
+                return -ENOMEM;
+
+        len = strlen(str);
+        p1 = str;
+
+        while (p1 < str + len) {
+                if (i >= num) {
+                        free(str);
+                        return -1;
+                }
+
+                p2 = strchr(p1, ',');
+                if (p2)
+                        *p2 = '\0';
+
+                ret = (func)(p1, &ptime_buf[i], start, end);
+                if (ret < 0) {
+                        free(str);
+                        return -1;
+                }
+
+                pr_debug("start time %d: %" PRIu64 ", ", i, ptime_buf[i].start);
+                pr_debug("end time %d: %" PRIu64 "\n", i, ptime_buf[i].end);
+
+                i++;
+
+                if (p2)
+                        p1 = p2 + 1;
+                else
+                        break;
+        }
+
+        free(str);
+        return i;
+}
+
+static int one_percent_convert(struct perf_time_interval *ptime_buf,
+                               const char *ostr, u64 start, u64 end, char *c)
+{
+        char *str;
+        int len = strlen(ostr), ret;
+
+        /*
+         * c points to '%'.
+         * '%' should be the last character
+         */
+        if (ostr + len - 1 != c)
+                return -1;
+
+        /*
+         * Construct a string like "xx%/1"
+         */
+        str = malloc(len + 3);
+        if (str == NULL)
+                return -ENOMEM;
+
+        memcpy(str, ostr, len);
+        strcpy(str + len, "/1");
+
+        ret = percent_slash_split(str, ptime_buf, start, end);
+        if (ret == 0)
+                ret = 1;
+
+        free(str);
+        return ret;
+}
+
+int perf_time__percent_parse_str(struct perf_time_interval *ptime_buf, int num,
+                                 const char *ostr, u64 start, u64 end)
+{
+        char *c;
+
+        /*
+         * ostr example:
+         * 10%/2,10%/3: select the second 10% slice and the third 10% slice
+         * 0%-10%,30%-40%: multiple time range
+         * 50%: just one percent
+         */
+
+        memset(ptime_buf, 0, sizeof(*ptime_buf) * num);
+
+        c = strchr(ostr, '/');
+        if (c) {
+                return percent_comma_split(ptime_buf, num, ostr, start,
+                                           end, percent_slash_split);
+        }
+
+        c = strchr(ostr, '-');
+        if (c) {
+                return percent_comma_split(ptime_buf, num, ostr, start,
+                                           end, percent_dash_split);
+        }
+
+        c = strchr(ostr, '%');
+        if (c)
+                return one_percent_convert(ptime_buf, ostr, start, end, c);
+
+        return -1;
+}
+
+struct perf_time_interval *perf_time__range_alloc(const char *ostr, int *size)
+{
+        const char *p1, *p2;
+        int i = 1;
+        struct perf_time_interval *ptime;
+
+        /*
+         * At least allocate one time range.
+         */
+        if (!ostr)
+                goto alloc;
+
+        p1 = ostr;
+        while (p1 < ostr + strlen(ostr)) {
+                p2 = strchr(p1, ',');
+                if (!p2)
+                        break;
+
+                p1 = p2 + 1;
+                i++;
+        }
+
+alloc:
+        *size = i;
+        ptime = calloc(i, sizeof(*ptime));
+        return ptime;
+}
+
 bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
 {
         /* if time is not set don't drop sample */
@@ -119,6 +368,34 @@ bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
         return false;
 }
 
+bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
+                                   int num, u64 timestamp)
+{
+        struct perf_time_interval *ptime;
+        int i;
+
+        if ((timestamp == 0) || (num == 0))
+                return false;
+
+        if (num == 1)
+                return perf_time__skip_sample(&ptime_buf[0], timestamp);
+
+        /*
+         * start/end of multiple time ranges must be valid.
+         */
+        for (i = 0; i < num; i++) {
+                ptime = &ptime_buf[i];
+
+                if (timestamp >= ptime->start &&
+                    ((timestamp < ptime->end && i < num - 1) ||
+                     (timestamp <= ptime->end && i == num - 1))) {
+                        break;
+                }
+        }
+
+        return (i == num) ? true : false;
+}
+
 int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
 {
         u64  sec = timestamp / NSEC_PER_SEC;