Merge tag 'perf-core-for-mingo' 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:

User visible changes:

  - Introduce 'srcfile' sort key: (Andi Kleen)

    # perf record -F 10000 usleep 1
    # perf report --stdio --dsos '[kernel.vmlinux]' -s srcfile
    <SNIP>
    # Overhead  Source File
        26.49%  copy_page_64.S
         5.49%  signal.c
         0.51%  msr.h
    #

    It can be combined with other fields, for instance, experiment with
    '-s srcfile,symbol'.

    There are some oddities in some distros and with some specific DSOs, being
    investigated, so your mileage may vary.

  - Update the column width for the "srcline" sort key (Arnaldo Carvalho de Melo)

  - Support per-event 'freq' term: (Namhyung Kim)

    $ perf record -e 'cpu/instructions,freq=1234/',cycles -c 1000 sleep 1
    $ perf evlist -F
    cpu/instructions,freq=1234/: sample_freq=1234
    cycles: sample_period=1000
    $

Infrastructure changes:

  - Move perf_counts struct and functions into separate object (Jiri Olsa)

  - Unset perf_event_attr::freq when period term is set (Jiri Olsa)

  - Move callchain option parsing code to util.c (Kan Liang)

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

1 files changed, 90 insertions, 0 deletions

diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index edc2d633b332..f7adf1203df1 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -566,6 +566,96 @@ unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
         return (unsigned long) -1;
 }
 
+int get_stack_size(const char *str, unsigned long *_size)
+{
+        char *endptr;
+        unsigned long size;
+        unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
+
+        size = strtoul(str, &endptr, 0);
+
+        do {
+                if (*endptr)
+                        break;
+
+                size = round_up(size, sizeof(u64));
+                if (!size || size > max_size)
+                        break;
+
+                *_size = size;
+                return 0;
+
+        } while (0);
+
+        pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
+               max_size, str);
+        return -1;
+}
+
+int parse_callchain_record(const char *arg, struct callchain_param *param)
+{
+        char *tok, *name, *saveptr = NULL;
+        char *buf;
+        int ret = -1;
+
+        /* We need buffer that we know we can write to. */
+        buf = malloc(strlen(arg) + 1);
+        if (!buf)
+                return -ENOMEM;
+
+        strcpy(buf, arg);
+
+        tok = strtok_r((char *)buf, ",", &saveptr);
+        name = tok ? : (char *)buf;
+
+        do {
+                /* Framepointer style */
+                if (!strncmp(name, "fp", sizeof("fp"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                param->record_mode = CALLCHAIN_FP;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                       "needed for --call-graph fp\n");
+                        break;
+
+#ifdef HAVE_DWARF_UNWIND_SUPPORT
+                /* Dwarf style */
+                } else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
+                        const unsigned long default_stack_dump_size = 8192;
+
+                        ret = 0;
+                        param->record_mode = CALLCHAIN_DWARF;
+                        param->dump_size = default_stack_dump_size;
+
+                        tok = strtok_r(NULL, ",", &saveptr);
+                        if (tok) {
+                                unsigned long size = 0;
+
+                                ret = get_stack_size(tok, &size);
+                                param->dump_size = size;
+                        }
+#endif /* HAVE_DWARF_UNWIND_SUPPORT */
+                } else if (!strncmp(name, "lbr", sizeof("lbr"))) {
+                        if (!strtok_r(NULL, ",", &saveptr)) {
+                                param->record_mode = CALLCHAIN_LBR;
+                                ret = 0;
+                        } else
+                                pr_err("callchain: No more arguments "
+                                        "needed for --call-graph lbr\n");
+                        break;
+                } else {
+                        pr_err("callchain: Unknown --call-graph option "
+                               "value: %s\n", arg);
+                        break;
+                }
+
+        } while (0);
+
+        free(buf);
+        return ret;
+}
+
 int filename__read_str(const char *filename, char **buf, size_t *sizep)
 {
         size_t size = 0, alloc_size = 0;