Merge tag 'perf-core-for-mingo-20161123' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

New tool:

- 'perf sched timehist' provides an analysis of scheduling events.

  Example usage:
      perf sched record -- sleep 1
      perf sched timehist

  By default it shows the individual schedule events, including the wait
  time (time between sched-out and next sched-in events for the task), the
  task scheduling delay (time between wakeup and actually running) and run
  time for the task:

        time    cpu  task name         wait time  sch delay  run time
                     [tid/pid]            (msec)     (msec)    (msec)
    -------- ------  ----------------  ---------  ---------  --------
    1.874569 [0011]  gcc[31949]            0.014      0.000     1.148
    1.874591 [0010]  gcc[31951]            0.000      0.000     0.024
    1.874603 [0010]  migration/10[59]      3.350      0.004     0.011
    1.874604 [0011]  <idle>                1.148      0.000     0.035
    1.874723 [0005]  <idle>                0.016      0.000     1.383
    1.874746 [0005]  gcc[31949]            0.153      0.078     0.022
  ...

  Times are in msec.usec. (David Ahern, Namhyung Kim)

Improvements:

- Make 'perf c2c report' support -f/--force, to allow skipping the
  ownership check for root users, for instance, just like the other
  tools (Jiri Olsa)

- Allow sorting cachelines by total number of HITMs, in addition to
  local and remote numbers (Jiri Olsa)

Fixes:

- Make sure errors aren't suppressed by the TUI reset at the end of
  a 'perf c2c report' session (Jiri Olsa)

Infrastructure changes:

- Initial work on having the annotate code better support multiple
  architectures, including the ability to cross-annotate, i.e. to
  annotate perf.data files collected on an ARM system on a x86_64
  workstation (Arnaldo Carvalho de Melo, Ravi Bangoria, Kim Phillips)

- Use USECS_PER_SEC instead of hard coded number in libtraceevent (Steven Rostedt)

- Add retrieval of preempt count and latency flags in libtraceevent (Steven Rostedt)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 127 insertions, 124 deletions

diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index aeb5a441bd74..095d90a9077f 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -18,17 +18,61 @@
 #include "annotate.h"
 #include "evsel.h"
 #include "block-range.h"
+#include "arch/common.h"
 #include <regex.h>
 #include <pthread.h>
 #include <linux/bitops.h>
+#include <sys/utsname.h>
 
 const char      *disassembler_style;
 const char      *objdump_path;
 static regex_t   file_lineno;
 
-static struct ins *ins__find(const char *name);
+static struct ins *ins__find(struct arch *arch, const char *name);
 static int disasm_line__parse(char *line, char **namep, char **rawp);
 
+struct arch {
+        const char      *name;
+        struct ins      *instructions;
+        size_t          nr_instructions;
+        bool            sorted_instructions;
+        struct          {
+                char comment_char;
+                char skip_functions_char;
+        } objdump;
+};
+
+static struct ins_ops call_ops;
+static struct ins_ops dec_ops;
+static struct ins_ops jump_ops;
+static struct ins_ops mov_ops;
+static struct ins_ops nop_ops;
+static struct ins_ops lock_ops;
+static struct ins_ops ret_ops;
+
+#include "arch/arm/annotate/instructions.c"
+#include "arch/x86/annotate/instructions.c"
+
+static struct arch architectures[] = {
+        {
+                .name = "arm",
+                .instructions = arm__instructions,
+                .nr_instructions = ARRAY_SIZE(arm__instructions),
+                .objdump =  {
+                        .comment_char = ';',
+                        .skip_functions_char = '+',
+                },
+        },
+        {
+                .name = "x86",
+                .instructions = x86__instructions,
+                .nr_instructions = ARRAY_SIZE(x86__instructions),
+                .objdump =  {
+                        .comment_char = '#',
+                },
+        },
+};
+
 static void ins__delete(struct ins_operands *ops)
 {
         if (ops == NULL)
@@ -54,7 +98,7 @@ int ins__scnprintf(struct ins *ins, char *bf, size_t size,
         return ins__raw_scnprintf(ins, bf, size, ops);
 }
 
-static int call__parse(struct ins_operands *ops, struct map *map)
+static int call__parse(struct arch *arch, struct ins_operands *ops, struct map *map)
 {
         char *endptr, *tok, *name;
 
@@ -66,10 +110,9 @@ static int call__parse(struct ins_operands *ops, struct map *map)
 
         name++;
 
-#ifdef __arm__
-        if (strchr(name, '+'))
+        if (arch->objdump.skip_functions_char &&
+            strchr(name, arch->objdump.skip_functions_char))
                 return -1;
-#endif
 
         tok = strchr(name, '>');
         if (tok == NULL)
@@ -118,7 +161,7 @@ bool ins__is_call(const struct ins *ins)
         return ins->ops == &call_ops;
 }
 
-static int jump__parse(struct ins_operands *ops, struct map *map __maybe_unused)
+static int jump__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map *map __maybe_unused)
 {
         const char *s = strchr(ops->raw, '+');
 
@@ -173,7 +216,7 @@ static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
         return 0;
 }
 
-static int lock__parse(struct ins_operands *ops, struct map *map)
+static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map *map)
 {
         char *name;
 
@@ -184,7 +227,7 @@ static int lock__parse(struct ins_operands *ops, struct map *map)
         if (disasm_line__parse(ops->raw, &name, &ops->locked.ops->raw) < 0)
                 goto out_free_ops;
 
-        ops->locked.ins = ins__find(name);
+        ops->locked.ins = ins__find(arch, name);
         free(name);
 
         if (ops->locked.ins == NULL)
@@ -194,7 +237,7 @@ static int lock__parse(struct ins_operands *ops, struct map *map)
                 return 0;
 
         if (ops->locked.ins->ops->parse &&
-            ops->locked.ins->ops->parse(ops->locked.ops, map) < 0)
+            ops->locked.ins->ops->parse(arch, ops->locked.ops, map) < 0)
                 goto out_free_ops;
 
         return 0;
@@ -237,7 +280,7 @@ static struct ins_ops lock_ops = {
         .scnprintf = lock__scnprintf,
 };
 
-static int mov__parse(struct ins_operands *ops, struct map *map __maybe_unused)
+static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map *map __maybe_unused)
 {
         char *s = strchr(ops->raw, ','), *target, *comment, prev;
 
@@ -252,11 +295,7 @@ static int mov__parse(struct ins_operands *ops, struct map *map __maybe_unused)
                 return -1;
 
         target = ++s;
-#ifdef __arm__
-        comment = strchr(s, ';');
-#else
-        comment = strchr(s, '#');
-#endif
+        comment = strchr(s, arch->objdump.comment_char);
 
         if (comment != NULL)
                 s = comment - 1;
@@ -304,7 +343,7 @@ static struct ins_ops mov_ops = {
         .scnprintf = mov__scnprintf,
 };
 
-static int dec__parse(struct ins_operands *ops, struct map *map __maybe_unused)
+static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map *map __maybe_unused)
 {
         char *target, *comment, *s, prev;
 
@@ -364,99 +403,6 @@ bool ins__is_ret(const struct ins *ins)
         return ins->ops == &ret_ops;
 }
 
-static struct ins instructions[] = {
-        { .name = "add",   .ops  = &mov_ops, },
-        { .name = "addl",  .ops  = &mov_ops, },
-        { .name = "addq",  .ops  = &mov_ops, },
-        { .name = "addw",  .ops  = &mov_ops, },
-        { .name = "and",   .ops  = &mov_ops, },
-#ifdef __arm__
-        { .name = "b",     .ops  = &jump_ops, }, // might also be a call
-        { .name = "bcc",   .ops  = &jump_ops, },
-        { .name = "bcs",   .ops  = &jump_ops, },
-        { .name = "beq",   .ops  = &jump_ops, },
-        { .name = "bge",   .ops  = &jump_ops, },
-        { .name = "bgt",   .ops  = &jump_ops, },
-        { .name = "bhi",   .ops  = &jump_ops, },
-        { .name = "bl",    .ops  = &call_ops, },
-        { .name = "bls",   .ops  = &jump_ops, },
-        { .name = "blt",   .ops  = &jump_ops, },
-        { .name = "blx",   .ops  = &call_ops, },
-        { .name = "bne",   .ops  = &jump_ops, },
-#endif
-        { .name = "bts",   .ops  = &mov_ops, },
-        { .name = "call",  .ops  = &call_ops, },
-        { .name = "callq", .ops  = &call_ops, },
-        { .name = "cmp",   .ops  = &mov_ops, },
-        { .name = "cmpb",  .ops  = &mov_ops, },
-        { .name = "cmpl",  .ops  = &mov_ops, },
-        { .name = "cmpq",  .ops  = &mov_ops, },
-        { .name = "cmpw",  .ops  = &mov_ops, },
-        { .name = "cmpxch", .ops  = &mov_ops, },
-        { .name = "dec",   .ops  = &dec_ops, },
-        { .name = "decl",  .ops  = &dec_ops, },
-        { .name = "imul",  .ops  = &mov_ops, },
-        { .name = "inc",   .ops  = &dec_ops, },
-        { .name = "incl",  .ops  = &dec_ops, },
-        { .name = "ja",    .ops  = &jump_ops, },
-        { .name = "jae",   .ops  = &jump_ops, },
-        { .name = "jb",    .ops  = &jump_ops, },
-        { .name = "jbe",   .ops  = &jump_ops, },
-        { .name = "jc",    .ops  = &jump_ops, },
-        { .name = "jcxz",  .ops  = &jump_ops, },
-        { .name = "je",    .ops  = &jump_ops, },
-        { .name = "jecxz", .ops  = &jump_ops, },
-        { .name = "jg",    .ops  = &jump_ops, },
-        { .name = "jge",   .ops  = &jump_ops, },
-        { .name = "jl",    .ops  = &jump_ops, },
-        { .name = "jle",   .ops  = &jump_ops, },
-        { .name = "jmp",   .ops  = &jump_ops, },
-        { .name = "jmpq",  .ops  = &jump_ops, },
-        { .name = "jna",   .ops  = &jump_ops, },
-        { .name = "jnae",  .ops  = &jump_ops, },
-        { .name = "jnb",   .ops  = &jump_ops, },
-        { .name = "jnbe",  .ops  = &jump_ops, },
-        { .name = "jnc",   .ops  = &jump_ops, },
-        { .name = "jne",   .ops  = &jump_ops, },
-        { .name = "jng",   .ops  = &jump_ops, },
-        { .name = "jnge",  .ops  = &jump_ops, },
-        { .name = "jnl",   .ops  = &jump_ops, },
-        { .name = "jnle",  .ops  = &jump_ops, },
-        { .name = "jno",   .ops  = &jump_ops, },
-        { .name = "jnp",   .ops  = &jump_ops, },
-        { .name = "jns",   .ops  = &jump_ops, },
-        { .name = "jnz",   .ops  = &jump_ops, },
-        { .name = "jo",    .ops  = &jump_ops, },
-        { .name = "jp",    .ops  = &jump_ops, },
-        { .name = "jpe",   .ops  = &jump_ops, },
-        { .name = "jpo",   .ops  = &jump_ops, },
-        { .name = "jrcxz", .ops  = &jump_ops, },
-        { .name = "js",    .ops  = &jump_ops, },
-        { .name = "jz",    .ops  = &jump_ops, },
-        { .name = "lea",   .ops  = &mov_ops, },
-        { .name = "lock",  .ops  = &lock_ops, },
-        { .name = "mov",   .ops  = &mov_ops, },
-        { .name = "movb",  .ops  = &mov_ops, },
-        { .name = "movdqa",.ops  = &mov_ops, },
-        { .name = "movl",  .ops  = &mov_ops, },
-        { .name = "movq",  .ops  = &mov_ops, },
-        { .name = "movslq", .ops  = &mov_ops, },
-        { .name = "movzbl", .ops  = &mov_ops, },
-        { .name = "movzwl", .ops  = &mov_ops, },
-        { .name = "nop",   .ops  = &nop_ops, },
-        { .name = "nopl",  .ops  = &nop_ops, },
-        { .name = "nopw",  .ops  = &nop_ops, },
-        { .name = "or",    .ops  = &mov_ops, },
-        { .name = "orl",   .ops  = &mov_ops, },
-        { .name = "test",  .ops  = &mov_ops, },
-        { .name = "testb", .ops  = &mov_ops, },
-        { .name = "testl", .ops  = &mov_ops, },
-        { .name = "xadd",  .ops  = &mov_ops, },
-        { .name = "xbeginl", .ops  = &jump_ops, },
-        { .name = "xbeginq", .ops  = &jump_ops, },
-        { .name = "retq",  .ops  = &ret_ops, },
-};
-
 static int ins__key_cmp(const void *name, const void *insp)
 {
         const struct ins *ins = insp;
@@ -472,24 +418,58 @@ static int ins__cmp(const void *a, const void *b)
         return strcmp(ia->name, ib->name);
 }
 
-static void ins__sort(void)
+static void ins__sort(struct arch *arch)
 {
-        const int nmemb = ARRAY_SIZE(instructions);
+        const int nmemb = arch->nr_instructions;
 
-        qsort(instructions, nmemb, sizeof(struct ins), ins__cmp);
+        qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp);
 }
 
-static struct ins *ins__find(const char *name)
+static struct ins *ins__find(struct arch *arch, const char *name)
 {
-        const int nmemb = ARRAY_SIZE(instructions);
+        const int nmemb = arch->nr_instructions;
+
+        if (!arch->sorted_instructions) {
+                ins__sort(arch);
+                arch->sorted_instructions = true;
+        }
+
+        return bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp);
+}
+
+static int arch__key_cmp(const void *name, const void *archp)
+{
+        const struct arch *arch = archp;
+
+        return strcmp(name, arch->name);
+}
+
+static int arch__cmp(const void *a, const void *b)
+{
+        const struct arch *aa = a;
+        const struct arch *ab = b;
+
+        return strcmp(aa->name, ab->name);
+}
+
+static void arch__sort(void)
+{
+        const int nmemb = ARRAY_SIZE(architectures);
+
+        qsort(architectures, nmemb, sizeof(struct arch), arch__cmp);
+}
+
+static struct arch *arch__find(const char *name)
+{
+        const int nmemb = ARRAY_SIZE(architectures);
         static bool sorted;
 
         if (!sorted) {
-                ins__sort();
+                arch__sort();
                 sorted = true;
         }
 
-        return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__key_cmp);
+        return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp);
 }
 
 int symbol__alloc_hist(struct symbol *sym)
@@ -709,9 +689,9 @@ int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
         return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
 }
 
-static void disasm_line__init_ins(struct disasm_line *dl, struct map *map)
+static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map *map)
 {
-        dl->ins = ins__find(dl->name);
+        dl->ins = ins__find(arch, dl->name);
 
         if (dl->ins == NULL)
                 return;
@@ -719,7 +699,7 @@ static void disasm_line__init_ins(struct disasm_line *dl, struct map *map)
         if (!dl->ins->ops)
                 return;
 
-        if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops, map) < 0)
+        if (dl->ins->ops->parse && dl->ins->ops->parse(arch, &dl->ops, map) < 0)
                 dl->ins = NULL;
 }
 
@@ -762,6 +742,7 @@ out_free_name:
 
 static struct disasm_line *disasm_line__new(s64 offset, char *line,
                                             size_t privsize, int line_nr,
+                                            struct arch *arch,
                                             struct map *map)
 {
         struct disasm_line *dl = zalloc(sizeof(*dl) + privsize);
@@ -777,7 +758,7 @@ static struct disasm_line *disasm_line__new(s64 offset, char *line,
                         if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0)
                                 goto out_free_line;
 
-                        disasm_line__init_ins(dl, map);
+                        disasm_line__init_ins(dl, arch, map);
                 }
         }
 
@@ -1087,6 +1068,7 @@ static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 st
  * The ops.raw part will be parsed further according to type of the instruction.
  */
 static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
+                                      struct arch *arch,
                                       FILE *file, size_t privsize,
                                       int *line_nr)
 {
@@ -1149,7 +1131,7 @@ static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
                         parsed_line = tmp2 + 1;
         }
 
-        dl = disasm_line__new(offset, parsed_line, privsize, *line_nr, map);
+        dl = disasm_line__new(offset, parsed_line, privsize, *line_nr, arch, map);
         free(line);
         (*line_nr)++;
 
@@ -1280,10 +1262,23 @@ fallback:
         return 0;
 }
 
-int symbol__disassemble(struct symbol *sym, struct map *map, size_t privsize)
+static const char *annotate__norm_arch(const char *arch_name)
+{
+        struct utsname uts;
+
+        if (!arch_name) { /* Assume we are annotating locally. */
+                if (uname(&uts) < 0)
+                        return NULL;
+                arch_name = uts.machine;
+        }
+        return normalize_arch((char *)arch_name);
+}
+
+int symbol__disassemble(struct symbol *sym, struct map *map, const char *arch_name, size_t privsize)
 {
         struct dso *dso = map->dso;
         char command[PATH_MAX * 2];
+        struct arch *arch = NULL;
         FILE *file;
         char symfs_filename[PATH_MAX];
         struct kcore_extract kce;
@@ -1297,6 +1292,14 @@ int symbol__disassemble(struct symbol *sym, struct map *map, size_t privsize)
         if (err)
                 return err;
 
+        arch_name = annotate__norm_arch(arch_name);
+        if (!arch_name)
+                return -1;
+
+        arch = arch__find(arch_name);
+        if (arch == NULL)
+                return -ENOTSUP;
+
         pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
                  symfs_filename, sym->name, map->unmap_ip(map, sym->start),
                  map->unmap_ip(map, sym->end));
@@ -1395,7 +1398,7 @@ int symbol__disassemble(struct symbol *sym, struct map *map, size_t privsize)
 
         nline = 0;
         while (!feof(file)) {
-                if (symbol__parse_objdump_line(sym, map, file, privsize,
+                if (symbol__parse_objdump_line(sym, map, arch, file, privsize,
                             &lineno) < 0)
                         break;
                 nline++;
@@ -1793,7 +1796,7 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map,
         struct rb_root source_line = RB_ROOT;
         u64 len;
 
-        if (symbol__disassemble(sym, map, 0) < 0)
+        if (symbol__disassemble(sym, map, perf_evsel__env_arch(evsel), 0) < 0)
                 return -1;
 
         len = symbol__size(sym);