Merge branches 'imx/pata' and 'imx/sata' into next/driver

Conflicts:
	arch/arm/mach-mx5/clock-mx51-mx53.c
	arch/arm/mach-mx5/devices-imx53.h

23 files changed, 662 insertions, 209 deletions

diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 56d62d3fb167..3b8f7b80376b 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -181,9 +181,9 @@ strip-libs = $(filter-out -l%,$(1))
 
 $(OUTPUT)python/perf.so: $(PYRF_OBJS)
         $(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
-          --quiet build_ext \
-          --build-lib='$(OUTPUT)python' \
-          --build-temp='$(OUTPUT)python/temp'
+          --quiet build_ext; \
+        mkdir -p $(OUTPUT)python && \
+        cp $(PYTHON_EXTBUILD_LIB)perf.so $(OUTPUT)python/
 #
 # No Perl scripts right now:
 #
@@ -509,9 +509,13 @@ else
 
   PYTHON_WORD := $(call shell-wordify,$(PYTHON))
 
-  python-clean := $(PYTHON_WORD) util/setup.py clean \
-    --build-lib='$(OUTPUT)python' \
-    --build-temp='$(OUTPUT)python/temp'
+  # python extension build directories
+  PYTHON_EXTBUILD     := $(OUTPUT)python_ext_build/
+  PYTHON_EXTBUILD_LIB := $(PYTHON_EXTBUILD)lib/
+  PYTHON_EXTBUILD_TMP := $(PYTHON_EXTBUILD)tmp/
+  export PYTHON_EXTBUILD_LIB PYTHON_EXTBUILD_TMP
+
+  python-clean := rm -rf $(PYTHON_EXTBUILD) $(OUTPUT)python/perf.so
 
   ifdef NO_LIBPYTHON
     $(call disable-python)
@@ -868,6 +872,9 @@ install: all
         $(INSTALL) scripts/python/*.py -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python'
         $(INSTALL) scripts/python/bin/* -t '$(DESTDIR_SQ)$(perfexec_instdir_SQ)/scripts/python/bin'
 
+install-python_ext:
+        $(PYTHON_WORD) util/setup.py --quiet install --root='/$(DESTDIR_SQ)'
+
 install-doc:
         $(MAKE) -C Documentation install
 
@@ -895,7 +902,7 @@ quick-install-html:
 ### Cleaning rules
 
 clean:
-        $(RM) $(OUTPUT){*.o,*/*.o,*/*/*.o,*/*/*/*.o,$(LIB_FILE),perf-archive}
+        $(RM) $(LIB_OBJS) $(BUILTIN_OBJS) $(LIB_FILE) $(OUTPUT)perf-archive $(OUTPUT)perf.o $(LANG_BINDINGS)
         $(RM) $(ALL_PROGRAMS) perf
         $(RM) *.spec *.pyc *.pyo */*.pyc */*.pyo $(OUTPUT)common-cmds.h TAGS tags cscope*
         $(MAKE) -C Documentation/ clean
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 9ac05aafd9b2..899080ace267 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -942,10 +942,10 @@ static const char *record_args[] = {
         "-f",
         "-m", "1024",
         "-c", "1",
-        "-e", "lock:lock_acquire:r",
-        "-e", "lock:lock_acquired:r",
-        "-e", "lock:lock_contended:r",
-        "-e", "lock:lock_release:r",
+        "-e", "lock:lock_acquire",
+        "-e", "lock:lock_acquired",
+        "-e", "lock:lock_contended",
+        "-e", "lock:lock_release",
 };
 
 static int __cmd_record(int argc, const char **argv)
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index 5f2a5c7046df..710ae3d0a489 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -134,10 +134,18 @@ static int opt_show_lines(const struct option *opt __used,
 {
         int ret = 0;
 
-        if (str)
-                ret = parse_line_range_desc(str, &params.line_range);
-        INIT_LIST_HEAD(&params.line_range.line_list);
+        if (!str)
+                return 0;
+
+        if (params.show_lines) {
+                pr_warning("Warning: more than one --line options are"
+                           " detected. Only the first one is valid.\n");
+                return 0;
+        }
+
         params.show_lines = true;
+        ret = parse_line_range_desc(str, &params.line_range);
+        INIT_LIST_HEAD(&params.line_range.line_list);
 
         return ret;
 }
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 80dc5b790e47..6b0519f885e4 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -30,8 +30,6 @@
 #include <sched.h>
 #include <sys/mman.h>
 
-#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
-
 enum write_mode_t {
         WRITE_FORCE,
         WRITE_APPEND
@@ -47,7 +45,7 @@ static int			freq				=   1000;
 static int                      output;
 static int                      pipe_output                     =      0;
 static const char               *output_name                    = NULL;
-static int                      group                           =      0;
+static bool                     group                           =  false;
 static int                      realtime_prio                   =      0;
 static bool                     nodelay                         =  false;
 static bool                     raw_samples                     =  false;
@@ -438,7 +436,6 @@ static void mmap_read_all(void)
 
 static int __cmd_record(int argc, const char **argv)
 {
-        int i;
         struct stat st;
         int flags;
         int err;
@@ -682,7 +679,6 @@ static int __cmd_record(int argc, const char **argv)
 
         for (;;) {
                 int hits = samples;
-                int thread;
 
                 mmap_read_all();
 
@@ -693,19 +689,8 @@ static int __cmd_record(int argc, const char **argv)
                         waking++;
                 }
 
-                if (done) {
-                        for (i = 0; i < evsel_list->cpus->nr; i++) {
-                                struct perf_evsel *pos;
-
-                                list_for_each_entry(pos, &evsel_list->entries, node) {
-                                        for (thread = 0;
-                                                thread < evsel_list->threads->nr;
-                                                thread++)
-                                                ioctl(FD(pos, i, thread),
-                                                        PERF_EVENT_IOC_DISABLE);
-                                }
-                        }
-                }
+                if (done)
+                        perf_evlist__disable(evsel_list);
         }
 
         if (quiet || signr == SIGUSR1)
@@ -768,6 +753,8 @@ const struct option record_options[] = {
                     "child tasks do not inherit counters"),
         OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
         OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
+        OPT_BOOLEAN(0, "group", &group,
+                    "put the counters into a counter group"),
         OPT_BOOLEAN('g', "call-graph", &call_graph,
                     "do call-graph (stack chain/backtrace) recording"),
         OPT_INCR('v', "verbose", &verbose,
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index f854efda7686..d7ff277bdb78 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -162,23 +162,22 @@ static int perf_session__setup_sample_type(struct perf_session *self)
 {
         if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
                 if (sort__has_parent) {
-                        fprintf(stderr, "selected --sort parent, but no"
-                                        " callchain data. Did you call"
-                                        " perf record without -g?\n");
+                        ui__warning("Selected --sort parent, but no "
+                                    "callchain data. Did you call "
+                                    "'perf record' without -g?\n");
                         return -EINVAL;
                 }
                 if (symbol_conf.use_callchain) {
-                        fprintf(stderr, "selected -g but no callchain data."
-                                        " Did you call perf record without"
-                                        " -g?\n");
+                        ui__warning("Selected -g but no callchain data. Did "
+                                    "you call 'perf record' without -g?\n");
                         return -1;
                 }
         } else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
                    !symbol_conf.use_callchain) {
                         symbol_conf.use_callchain = true;
                         if (callchain_register_param(&callchain_param) < 0) {
-                                fprintf(stderr, "Can't register callchain"
-                                                " params\n");
+                                ui__warning("Can't register callchain "
+                                            "params.\n");
                                 return -EINVAL;
                         }
         }
diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index dcfe8873c9a1..5177964943e7 100644
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -1637,23 +1637,29 @@ static struct perf_event_ops event_ops = {
         .ordered_samples        = true,
 };
 
-static int read_events(void)
+static void read_events(bool destroy, struct perf_session **psession)
 {
         int err = -EINVAL;
         struct perf_session *session = perf_session__new(input_name, O_RDONLY,
                                                          0, false, &event_ops);
         if (session == NULL)
-                return -ENOMEM;
+                die("No Memory");
 
         if (perf_session__has_traces(session, "record -R")) {
                 err = perf_session__process_events(session, &event_ops);
+                if (err)
+                        die("Failed to process events, error %d", err);
+
                 nr_events      = session->hists.stats.nr_events[0];
                 nr_lost_events = session->hists.stats.total_lost;
                 nr_lost_chunks = session->hists.stats.nr_events[PERF_RECORD_LOST];
         }
 
-        perf_session__delete(session);
-        return err;
+        if (destroy)
+                perf_session__delete(session);
+
+        if (psession)
+                *psession = session;
 }
 
 static void print_bad_events(void)
@@ -1689,9 +1695,10 @@ static void print_bad_events(void)
 static void __cmd_lat(void)
 {
         struct rb_node *next;
+        struct perf_session *session;
 
         setup_pager();
-        read_events();
+        read_events(false, &session);
         sort_lat();
 
         printf("\n ---------------------------------------------------------------------------------------------------------------\n");
@@ -1717,6 +1724,7 @@ static void __cmd_lat(void)
         print_bad_events();
         printf("\n");
 
+        perf_session__delete(session);
 }
 
 static struct trace_sched_handler map_ops  = {
@@ -1731,7 +1739,7 @@ static void __cmd_map(void)
         max_cpu = sysconf(_SC_NPROCESSORS_CONF);
 
         setup_pager();
-        read_events();
+        read_events(true, NULL);
         print_bad_events();
 }
 
@@ -1744,7 +1752,7 @@ static void __cmd_replay(void)
 
         test_calibrations();
 
-        read_events();
+        read_events(true, NULL);
 
         printf("nr_run_events:        %ld\n", nr_run_events);
         printf("nr_sleep_events:      %ld\n", nr_sleep_events);
@@ -1769,7 +1777,7 @@ static void __cmd_replay(void)
 
 
 static const char * const sched_usage[] = {
-        "perf sched [<options>] {record|latency|map|replay|trace}",
+        "perf sched [<options>] {record|latency|map|replay|script}",
         NULL
 };
 
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 1ad04ce29c34..5deb17d9e795 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -193,6 +193,7 @@ static int			big_num_opt			=  -1;
 static const char               *cpu_list;
 static const char               *csv_sep                        = NULL;
 static bool                     csv_output                      = false;
+static bool                     group                           = false;
 
 static volatile int done = 0;
 
@@ -280,14 +281,14 @@ static int create_perf_stat_counter(struct perf_evsel *evsel)
         attr->inherit = !no_inherit;
 
         if (system_wide)
-                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, false);
+                return perf_evsel__open_per_cpu(evsel, evsel_list->cpus, group);
 
         if (target_pid == -1 && target_tid == -1) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
 
-        return perf_evsel__open_per_thread(evsel, evsel_list->threads, false);
+        return perf_evsel__open_per_thread(evsel, evsel_list->threads, group);
 }
 
 /*
@@ -1043,6 +1044,8 @@ static const struct option options[] = {
                     "stat events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
+        OPT_BOOLEAN('g', "group", &group,
+                    "put the counters into a counter group"),
         OPT_BOOLEAN('c', "scale", &scale,
                     "scale/normalize counters"),
         OPT_INCR('v', "verbose", &verbose,
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index e02d78cae70f..fe02903f7d0f 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -399,7 +399,6 @@ static int perf_config_global(void)
 int perf_config(config_fn_t fn, void *data)
 {
         int ret = 0, found = 0;
-        char *repo_config = NULL;
         const char *home = NULL;
 
         /* Setting $PERF_CONFIG makes perf read _only_ the given config file. */
@@ -414,19 +413,32 @@ int perf_config(config_fn_t fn, void *data)
         home = getenv("HOME");
         if (perf_config_global() && home) {
                 char *user_config = strdup(mkpath("%s/.perfconfig", home));
-                if (!access(user_config, R_OK)) {
-                        ret += perf_config_from_file(fn, user_config, data);
-                        found += 1;
+                struct stat st;
+
+                if (user_config == NULL) {
+                        warning("Not enough memory to process %s/.perfconfig, "
+                                "ignoring it.", home);
+                        goto out;
                 }
-                free(user_config);
-        }
 
-        repo_config = perf_pathdup("config");
-        if (!access(repo_config, R_OK)) {
-                ret += perf_config_from_file(fn, repo_config, data);
+                if (stat(user_config, &st) < 0)
+                        goto out_free;
+
+                if (st.st_uid && (st.st_uid != geteuid())) {
+                        warning("File %s not owned by current user or root, "
+                                "ignoring it.", user_config);
+                        goto out_free;
+                }
+
+                if (!st.st_size)
+                        goto out_free;
+
+                ret += perf_config_from_file(fn, user_config, data);
                 found += 1;
+out_free:
+                free(user_config);
         }
-        free(repo_config);
+out:
         if (found == 0)
                 return -1;
         return ret;
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index fddf40f30d3e..ee51e9b4dc09 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -96,6 +96,39 @@ int cu_find_lineinfo(Dwarf_Die *cu_die, unsigned long addr,
         return *lineno ?: -ENOENT;
 }
 
+static int __die_find_inline_cb(Dwarf_Die *die_mem, void *data);
+
+/**
+ * cu_walk_functions_at - Walk on function DIEs at given address
+ * @cu_die: A CU DIE
+ * @addr: An address
+ * @callback: A callback which called with found DIEs
+ * @data: A user data
+ *
+ * Walk on function DIEs at given @addr in @cu_die. Passed DIEs
+ * should be subprogram or inlined-subroutines.
+ */
+int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                    int (*callback)(Dwarf_Die *, void *), void *data)
+{
+        Dwarf_Die die_mem;
+        Dwarf_Die *sc_die;
+        int ret = -ENOENT;
+
+        /* Inlined function could be recursive. Trace it until fail */
+        for (sc_die = die_find_realfunc(cu_die, addr, &die_mem);
+             sc_die != NULL;
+             sc_die = die_find_child(sc_die, __die_find_inline_cb, &addr,
+                                     &die_mem)) {
+                ret = callback(sc_die, data);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+
+}
+
 /**
  * die_compare_name - Compare diename and tname
  * @dw_die: a DIE
@@ -198,6 +231,19 @@ static int die_get_attr_udata(Dwarf_Die *tp_die, unsigned int attr_name,
         return 0;
 }
 
+/* Get attribute and translate it as a sdata */
+static int die_get_attr_sdata(Dwarf_Die *tp_die, unsigned int attr_name,
+                              Dwarf_Sword *result)
+{
+        Dwarf_Attribute attr;
+
+        if (dwarf_attr(tp_die, attr_name, &attr) == NULL ||
+            dwarf_formsdata(&attr, result) != 0)
+                return -ENOENT;
+
+        return 0;
+}
+
 /**
  * die_is_signed_type - Check whether a type DIE is signed or not
  * @tp_die: a DIE of a type
@@ -250,6 +296,50 @@ int die_get_data_member_location(Dwarf_Die *mb_die, Dwarf_Word *offs)
         return 0;
 }
 
+/* Get the call file index number in CU DIE */
+static int die_get_call_fileno(Dwarf_Die *in_die)
+{
+        Dwarf_Sword idx;
+
+        if (die_get_attr_sdata(in_die, DW_AT_call_file, &idx) == 0)
+                return (int)idx;
+        else
+                return -ENOENT;
+}
+
+/* Get the declared file index number in CU DIE */
+static int die_get_decl_fileno(Dwarf_Die *pdie)
+{
+        Dwarf_Sword idx;
+
+        if (die_get_attr_sdata(pdie, DW_AT_decl_file, &idx) == 0)
+                return (int)idx;
+        else
+                return -ENOENT;
+}
+
+/**
+ * die_get_call_file - Get callsite file name of inlined function instance
+ * @in_die: a DIE of an inlined function instance
+ *
+ * Get call-site file name of @in_die. This means from which file the inline
+ * function is called.
+ */
+const char *die_get_call_file(Dwarf_Die *in_die)
+{
+        Dwarf_Die cu_die;
+        Dwarf_Files *files;
+        int idx;
+
+        idx = die_get_call_fileno(in_die);
+        if (idx < 0 || !dwarf_diecu(in_die, &cu_die, NULL, NULL) ||
+            dwarf_getsrcfiles(&cu_die, &files, NULL) != 0)
+                return NULL;
+
+        return dwarf_filesrc(files, idx, NULL, NULL);
+}
+
+
 /**
  * die_find_child - Generic DIE search function in DIE tree
  * @rt_die: a root DIE
@@ -374,9 +464,78 @@ Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
         return die_mem;
 }
 
+struct __instance_walk_param {
+        void    *addr;
+        int     (*callback)(Dwarf_Die *, void *);
+        void    *data;
+        int     retval;
+};
+
+static int __die_walk_instances_cb(Dwarf_Die *inst, void *data)
+{
+        struct __instance_walk_param *iwp = data;
+        Dwarf_Attribute attr_mem;
+        Dwarf_Die origin_mem;
+        Dwarf_Attribute *attr;
+        Dwarf_Die *origin;
+        int tmp;
+
+        attr = dwarf_attr(inst, DW_AT_abstract_origin, &attr_mem);
+        if (attr == NULL)
+                return DIE_FIND_CB_CONTINUE;
+
+        origin = dwarf_formref_die(attr, &origin_mem);
+        if (origin == NULL || origin->addr != iwp->addr)
+                return DIE_FIND_CB_CONTINUE;
+
+        /* Ignore redundant instances */
+        if (dwarf_tag(inst) == DW_TAG_inlined_subroutine) {
+                dwarf_decl_line(origin, &tmp);
+                if (die_get_call_lineno(inst) == tmp) {
+                        tmp = die_get_decl_fileno(origin);
+                        if (die_get_call_fileno(inst) == tmp)
+                                return DIE_FIND_CB_CONTINUE;
+                }
+        }
+
+        iwp->retval = iwp->callback(inst, iwp->data);
+
+        return (iwp->retval) ? DIE_FIND_CB_END : DIE_FIND_CB_CONTINUE;
+}
+
+/**
+ * die_walk_instances - Walk on instances of given DIE
+ * @or_die: an abstract original DIE
+ * @callback: a callback function which is called with instance DIE
+ * @data: user data
+ *
+ * Walk on the instances of give @in_die. @in_die must be an inlined function
+ * declartion. This returns the return value of @callback if it returns
+ * non-zero value, or -ENOENT if there is no instance.
+ */
+int die_walk_instances(Dwarf_Die *or_die, int (*callback)(Dwarf_Die *, void *),
+                       void *data)
+{
+        Dwarf_Die cu_die;
+        Dwarf_Die die_mem;
+        struct __instance_walk_param iwp = {
+                .addr = or_die->addr,
+                .callback = callback,
+                .data = data,
+                .retval = -ENOENT,
+        };
+
+        if (dwarf_diecu(or_die, &cu_die, NULL, NULL) == NULL)
+                return -ENOENT;
+
+        die_find_child(&cu_die, __die_walk_instances_cb, &iwp, &die_mem);
+
+        return iwp.retval;
+}
+
 /* Line walker internal parameters */
 struct __line_walk_param {
-        const char *fname;
+        bool recursive;
         line_walk_callback_t callback;
         void *data;
         int retval;
@@ -385,39 +544,56 @@ struct __line_walk_param {
 static int __die_walk_funclines_cb(Dwarf_Die *in_die, void *data)
 {
         struct __line_walk_param *lw = data;
-        Dwarf_Addr addr;
+        Dwarf_Addr addr = 0;
+        const char *fname;
         int lineno;
 
         if (dwarf_tag(in_die) == DW_TAG_inlined_subroutine) {
+                fname = die_get_call_file(in_die);
                 lineno = die_get_call_lineno(in_die);
-                if (lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
-                        lw->retval = lw->callback(lw->fname, lineno, addr,
-                                                  lw->data);
+                if (fname && lineno > 0 && dwarf_entrypc(in_die, &addr) == 0) {
+                        lw->retval = lw->callback(fname, lineno, addr, lw->data);
                         if (lw->retval != 0)
                                 return DIE_FIND_CB_END;
                 }
         }
-        return DIE_FIND_CB_SIBLING;
+        if (!lw->recursive)
+                /* Don't need to search recursively */
+                return DIE_FIND_CB_SIBLING;
+
+        if (addr) {
+                fname = dwarf_decl_file(in_die);
+                if (fname && dwarf_decl_line(in_die, &lineno) == 0) {
+                        lw->retval = lw->callback(fname, lineno, addr, lw->data);
+                        if (lw->retval != 0)
+                                return DIE_FIND_CB_END;
+                }
+        }
+
+        /* Continue to search nested inlined function call-sites */
+        return DIE_FIND_CB_CONTINUE;
 }
 
 /* Walk on lines of blocks included in given DIE */
-static int __die_walk_funclines(Dwarf_Die *sp_die,
+static int __die_walk_funclines(Dwarf_Die *sp_die, bool recursive,
                                 line_walk_callback_t callback, void *data)
 {
         struct __line_walk_param lw = {
+                .recursive = recursive,
                 .callback = callback,
                 .data = data,
                 .retval = 0,
         };
         Dwarf_Die die_mem;
         Dwarf_Addr addr;
+        const char *fname;
         int lineno;
 
         /* Handle function declaration line */
-        lw.fname = dwarf_decl_file(sp_die);
-        if (lw.fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
+        fname = dwarf_decl_file(sp_die);
+        if (fname && dwarf_decl_line(sp_die, &lineno) == 0 &&
             dwarf_entrypc(sp_die, &addr) == 0) {
-                lw.retval = callback(lw.fname, lineno, addr, data);
+                lw.retval = callback(fname, lineno, addr, data);
                 if (lw.retval != 0)
                         goto done;
         }
@@ -430,7 +606,7 @@ static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 {
         struct __line_walk_param *lw = data;
 
-        lw->retval = __die_walk_funclines(sp_die, lw->callback, lw->data);
+        lw->retval = __die_walk_funclines(sp_die, true, lw->callback, lw->data);
         if (lw->retval != 0)
                 return DWARF_CB_ABORT;
 
@@ -439,7 +615,7 @@ static int __die_walk_culines_cb(Dwarf_Die *sp_die, void *data)
 
 /**
  * die_walk_lines - Walk on lines inside given DIE
- * @rt_die: a root DIE (CU or subprogram)
+ * @rt_die: a root DIE (CU, subprogram or inlined_subroutine)
  * @callback: callback routine
  * @data: user data
  *
@@ -460,12 +636,12 @@ int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
         size_t nlines, i;
 
         /* Get the CU die */
-        if (dwarf_tag(rt_die) == DW_TAG_subprogram)
+        if (dwarf_tag(rt_die) != DW_TAG_compile_unit)
                 cu_die = dwarf_diecu(rt_die, &die_mem, NULL, NULL);
         else
                 cu_die = rt_die;
         if (!cu_die) {
-                pr_debug2("Failed to get CU from subprogram\n");
+                pr_debug2("Failed to get CU from given DIE.\n");
                 return -EINVAL;
         }
 
@@ -509,7 +685,11 @@ int die_walk_lines(Dwarf_Die *rt_die, line_walk_callback_t callback, void *data)
          * subroutines. We have to check functions list or given function.
          */
         if (rt_die != cu_die)
-                ret = __die_walk_funclines(rt_die, callback, data);
+                /*
+                 * Don't need walk functions recursively, because nested
+                 * inlined functions don't have lines of the specified DIE.
+                 */
+                ret = __die_walk_funclines(rt_die, false, callback, data);
         else {
                 struct __line_walk_param param = {
                         .callback = callback,
diff --git a/tools/perf/util/dwarf-aux.h b/tools/perf/util/dwarf-aux.h
index bc3b21167e70..6ce1717784b7 100644
--- a/tools/perf/util/dwarf-aux.h
+++ b/tools/perf/util/dwarf-aux.h
@@ -34,12 +34,19 @@ extern const char *cu_get_comp_dir(Dwarf_Die *cu_die);
 extern int cu_find_lineinfo(Dwarf_Die *cudie, unsigned long addr,
                             const char **fname, int *lineno);
 
+/* Walk on funcitons at given address */
+extern int cu_walk_functions_at(Dwarf_Die *cu_die, Dwarf_Addr addr,
+                        int (*callback)(Dwarf_Die *, void *), void *data);
+
 /* Compare diename and tname */
 extern bool die_compare_name(Dwarf_Die *dw_die, const char *tname);
 
 /* Get callsite line number of inline-function instance */
 extern int die_get_call_lineno(Dwarf_Die *in_die);
 
+/* Get callsite file name of inlined function instance */
+extern const char *die_get_call_file(Dwarf_Die *in_die);
+
 /* Get type die */
 extern Dwarf_Die *die_get_type(Dwarf_Die *vr_die, Dwarf_Die *die_mem);
 
@@ -73,6 +80,10 @@ extern Dwarf_Die *die_find_realfunc(Dwarf_Die *cu_die, Dwarf_Addr addr,
 extern Dwarf_Die *die_find_inlinefunc(Dwarf_Die *sp_die, Dwarf_Addr addr,
                                       Dwarf_Die *die_mem);
 
+/* Walk on the instances of given DIE */
+extern int die_walk_instances(Dwarf_Die *in_die,
+                              int (*callback)(Dwarf_Die *, void *), void *data);
+
 /* Walker on lines (Note: line number will not be sorted) */
 typedef int (* line_walk_callback_t) (const char *fname, int lineno,
                                       Dwarf_Addr addr, void *data);
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index b021ea9265c3..c12bd476c6f7 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -85,10 +85,32 @@ int perf_evlist__add_default(struct perf_evlist *evlist)
         struct perf_evsel *evsel = perf_evsel__new(&attr, 0);
 
         if (evsel == NULL)
-                return -ENOMEM;
+                goto error;
+
+        /* use strdup() because free(evsel) assumes name is allocated */
+        evsel->name = strdup("cycles");
+        if (!evsel->name)
+                goto error_free;
 
         perf_evlist__add(evlist, evsel);
         return 0;
+error_free:
+        perf_evsel__delete(evsel);
+error:
+        return -ENOMEM;
+}
+
+void perf_evlist__disable(struct perf_evlist *evlist)
+{
+        int cpu, thread;
+        struct perf_evsel *pos;
+
+        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+                list_for_each_entry(pos, &evlist->entries, node) {
+                        for (thread = 0; thread < evlist->threads->nr; thread++)
+                                ioctl(FD(pos, cpu, thread), PERF_EVENT_IOC_DISABLE);
+                }
+        }
 }
 
 int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index b2b862374f37..ce85ae9ae57a 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -53,6 +53,8 @@ int perf_evlist__alloc_mmap(struct perf_evlist *evlist);
 int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite);
 void perf_evlist__munmap(struct perf_evlist *evlist);
 
+void perf_evlist__disable(struct perf_evlist *evlist);
+
 static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
                                          struct cpu_map *cpus,
                                          struct thread_map *threads)
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index cb2959a3fb43..b6c1ad123ca9 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -189,8 +189,8 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms)
 {
         const size_t size = PATH_MAX;
-        char *realname, *filename = malloc(size),
-             *linkname = malloc(size), *targetname;
+        char *realname, *filename = zalloc(size),
+             *linkname = zalloc(size), *targetname;
         int len, err = -1;
 
         if (is_kallsyms) {
@@ -254,8 +254,8 @@ static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
 {
         const size_t size = PATH_MAX;
-        char *filename = malloc(size),
-             *linkname = malloc(size);
+        char *filename = zalloc(size),
+             *linkname = zalloc(size);
         int err = -1;
 
         if (filename == NULL || linkname == NULL)
@@ -726,7 +726,16 @@ static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
                         return -1;
 
                 bev.header = old_bev.header;
-                bev.pid    = 0;
+
+                /*
+                 * As the pid is the missing value, we need to fill
+                 * it properly. The header.misc value give us nice hint.
+                 */
+                bev.pid = HOST_KERNEL_ID;
+                if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
+                    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
+                        bev.pid = DEFAULT_GUEST_KERNEL_ID;
+
                 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
                 __event_process_build_id(&bev, filename, session);
 
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index 791f9dd27ebf..547628e97f3d 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -5,7 +5,9 @@
 #define __always_inline inline
 #endif
 #define __user
+#ifndef __attribute_const__
 #define __attribute_const__
+#endif
 
 #define __used          __attribute__((__unused__))
 
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 4ea7e19f5251..928918b796b2 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -697,7 +697,11 @@ parse_raw_event(const char **strp, struct perf_event_attr *attr)
                 return EVT_FAILED;
         n = hex2u64(str + 1, &config);
         if (n > 0) {
-                *strp = str + n + 1;
+                const char *end = str + n + 1;
+                if (*end != '\0' && *end != ',' && *end != ':')
+                        return EVT_FAILED;
+
+                *strp = end;
                 attr->type = PERF_TYPE_RAW;
                 attr->config = config;
                 return EVT_HANDLED;
@@ -1097,6 +1101,4 @@ void print_events(const char *event_glob)
         printf("\n");
 
         print_tracepoint_events(NULL, NULL);
-
-        exit(129);
 }
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index b82d54fa2c56..1c7bfa5fe0a8 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1820,11 +1820,15 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                 ret = -ENOMEM;
                 goto error;
         }
-        tev->point.module = strdup(module);
-        if (tev->point.module == NULL) {
-                ret = -ENOMEM;
-                goto error;
+
+        if (module) {
+                tev->point.module = strdup(module);
+                if (tev->point.module == NULL) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
         }
+
         tev->point.offset = pev->point.offset;
         tev->point.retprobe = pev->point.retprobe;
         tev->nargs = pev->nargs;
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 3e44a3e36519..555fc3864b90 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -612,12 +612,12 @@ static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
         return ret;
 }
 
-/* Find a variable in a subprogram die */
-static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
+/* Find a variable in a scope DIE */
+static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
-        Dwarf_Die vr_die, *scopes;
+        Dwarf_Die vr_die;
         char buf[32], *ptr;
-        int ret, nscopes;
+        int ret = 0;
 
         if (!is_c_varname(pf->pvar->var)) {
                 /* Copy raw parameters */
@@ -652,30 +652,16 @@ static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
         if (pf->tvar->name == NULL)
                 return -ENOMEM;
 
-        pr_debug("Searching '%s' variable in context.\n",
-                 pf->pvar->var);
+        pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
         /* Search child die for local variables and parameters. */
-        if (die_find_variable_at(sp_die, pf->pvar->var, pf->addr, &vr_die))
-                ret = convert_variable(&vr_die, pf);
-        else {
-                /* Search upper class */
-                nscopes = dwarf_getscopes_die(sp_die, &scopes);
-                while (nscopes-- > 1) {
-                        pr_debug("Searching variables in %s\n",
-                                 dwarf_diename(&scopes[nscopes]));
-                        /* We should check this scope, so give dummy address */
-                        if (die_find_variable_at(&scopes[nscopes],
-                                                 pf->pvar->var, 0,
-                                                 &vr_die)) {
-                                ret = convert_variable(&vr_die, pf);
-                                goto found;
-                        }
-                }
-                if (scopes)
-                        free(scopes);
-                ret = -ENOENT;
+        if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
+                /* Search again in global variables */
+                if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 0, &vr_die))
+                        ret = -ENOENT;
         }
-found:
+        if (ret == 0)
+                ret = convert_variable(&vr_die, pf);
+
         if (ret < 0)
                 pr_warning("Failed to find '%s' in this function.\n",
                            pf->pvar->var);
@@ -718,26 +704,30 @@ static int convert_to_trace_point(Dwarf_Die *sp_die, Dwarf_Addr paddr,
         return 0;
 }
 
-/* Call probe_finder callback with real subprogram DIE */
-static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
+/* Call probe_finder callback with scope DIE */
+static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
-        Dwarf_Die die_mem;
         Dwarf_Attribute fb_attr;
         size_t nops;
         int ret;
 
-        /* If no real subprogram, find a real one */
-        if (!sp_die || dwarf_tag(sp_die) != DW_TAG_subprogram) {
-                sp_die = die_find_realfunc(&pf->cu_die, pf->addr, &die_mem);
-                if (!sp_die) {
+        if (!sc_die) {
+                pr_err("Caller must pass a scope DIE. Program error.\n");
+                return -EINVAL;
+        }
+
+        /* If not a real subprogram, find a real one */
+        if (dwarf_tag(sc_die) != DW_TAG_subprogram) {
+                if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
                         pr_warning("Failed to find probe point in any "
                                    "functions.\n");
                         return -ENOENT;
                 }
-        }
+        } else
+                memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
 
-        /* Get the frame base attribute/ops */
-        dwarf_attr(sp_die, DW_AT_frame_base, &fb_attr);
+        /* Get the frame base attribute/ops from subprogram */
+        dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
         ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
         if (ret <= 0 || nops == 0) {
                 pf->fb_ops = NULL;
@@ -755,7 +745,7 @@ static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
 
         /* Call finder's callback handler */
-        ret = pf->callback(sp_die, pf);
+        ret = pf->callback(sc_die, pf);
 
         /* *pf->fb_ops will be cached in libdw. Don't free it. */
         pf->fb_ops = NULL;
@@ -763,17 +753,82 @@ static int call_probe_finder(Dwarf_Die *sp_die, struct probe_finder *pf)
         return ret;
 }
 
+struct find_scope_param {
+        const char *function;
+        const char *file;
+        int line;
+        int diff;
+        Dwarf_Die *die_mem;
+        bool found;
+};
+
+static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
+{
+        struct find_scope_param *fsp = data;
+        const char *file;
+        int lno;
+
+        /* Skip if declared file name does not match */
+        if (fsp->file) {
+                file = dwarf_decl_file(fn_die);
+                if (!file || strcmp(fsp->file, file) != 0)
+                        return 0;
+        }
+        /* If the function name is given, that's what user expects */
+        if (fsp->function) {
+                if (die_compare_name(fn_die, fsp->function)) {
+                        memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
+                        fsp->found = true;
+                        return 1;
+                }
+        } else {
+                /* With the line number, find the nearest declared DIE */
+                dwarf_decl_line(fn_die, &lno);
+                if (lno < fsp->line && fsp->diff > fsp->line - lno) {
+                        /* Keep a candidate and continue */
+                        fsp->diff = fsp->line - lno;
+                        memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
+                        fsp->found = true;
+                }
+        }
+        return 0;
+}
+
+/* Find an appropriate scope fits to given conditions */
+static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
+{
+        struct find_scope_param fsp = {
+                .function = pf->pev->point.function,
+                .file = pf->fname,
+                .line = pf->lno,
+                .diff = INT_MAX,
+                .die_mem = die_mem,
+                .found = false,
+        };
+
+        cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, &fsp);
+
+        return fsp.found ? die_mem : NULL;
+}
+
 static int probe_point_line_walker(const char *fname, int lineno,
                                    Dwarf_Addr addr, void *data)
 {
         struct probe_finder *pf = data;
+        Dwarf_Die *sc_die, die_mem;
         int ret;
 
         if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
                 return 0;
 
         pf->addr = addr;
-        ret = call_probe_finder(NULL, pf);
+        sc_die = find_best_scope(pf, &die_mem);
+        if (!sc_die) {
+                pr_warning("Failed to find scope of probe point.\n");
+                return -ENOENT;
+        }
+
+        ret = call_probe_finder(sc_die, pf);
 
         /* Continue if no error, because the line will be in inline function */
         return ret < 0 ? ret : 0;
@@ -827,6 +882,7 @@ static int probe_point_lazy_walker(const char *fname, int lineno,
                                    Dwarf_Addr addr, void *data)
 {
         struct probe_finder *pf = data;
+        Dwarf_Die *sc_die, die_mem;
         int ret;
 
         if (!line_list__has_line(&pf->lcache, lineno) ||
@@ -836,7 +892,14 @@ static int probe_point_lazy_walker(const char *fname, int lineno,
         pr_debug("Probe line found: line:%d addr:0x%llx\n",
                  lineno, (unsigned long long)addr);
         pf->addr = addr;
-        ret = call_probe_finder(NULL, pf);
+        pf->lno = lineno;
+        sc_die = find_best_scope(pf, &die_mem);
+        if (!sc_die) {
+                pr_warning("Failed to find scope of probe point.\n");
+                return -ENOENT;
+        }
+
+        ret = call_probe_finder(sc_die, pf);
 
         /*
          * Continue if no error, because the lazy pattern will match
@@ -861,42 +924,39 @@ static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
         return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
 }
 
-/* Callback parameter with return value */
-struct dwarf_callback_param {
-        void *data;
-        int retval;
-};
-
 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct dwarf_callback_param *param = data;
-        struct probe_finder *pf = param->data;
+        struct probe_finder *pf = data;
         struct perf_probe_point *pp = &pf->pev->point;
         Dwarf_Addr addr;
+        int ret;
 
         if (pp->lazy_line)
-                param->retval = find_probe_point_lazy(in_die, pf);
+                ret = find_probe_point_lazy(in_die, pf);
         else {
                 /* Get probe address */
                 if (dwarf_entrypc(in_die, &addr) != 0) {
                         pr_warning("Failed to get entry address of %s.\n",
                                    dwarf_diename(in_die));
-                        param->retval = -ENOENT;
-                        return DWARF_CB_ABORT;
+                        return -ENOENT;
                 }
                 pf->addr = addr;
                 pf->addr += pp->offset;
                 pr_debug("found inline addr: 0x%jx\n",
                          (uintmax_t)pf->addr);
 
-                param->retval = call_probe_finder(in_die, pf);
-                if (param->retval < 0)
-                        return DWARF_CB_ABORT;
+                ret = call_probe_finder(in_die, pf);
         }
 
-        return DWARF_CB_OK;
+        return ret;
 }
 
+/* Callback parameter with return value for libdw */
+struct dwarf_callback_param {
+        void *data;
+        int retval;
+};
+
 /* Search function from function name */
 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
 {
@@ -933,14 +993,10 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
                         /* TODO: Check the address in this function */
                         param->retval = call_probe_finder(sp_die, pf);
                 }
-        } else {
-                struct dwarf_callback_param _param = {.data = (void *)pf,
-                                                      .retval = 0};
+        } else
                 /* Inlined function: search instances */
-                dwarf_func_inline_instances(sp_die, probe_point_inline_cb,
-                                            &_param);
-                param->retval = _param.retval;
-        }
+                param->retval = die_walk_instances(sp_die,
+                                        probe_point_inline_cb, (void *)pf);
 
         return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
 }
@@ -1060,7 +1116,7 @@ found:
 }
 
 /* Add a found probe point into trace event list */
-static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
         struct trace_event_finder *tf =
                         container_of(pf, struct trace_event_finder, pf);
@@ -1075,8 +1131,9 @@ static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
         tev = &tf->tevs[tf->ntevs++];
 
-        ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
-                                     &tev->point);
+        /* Trace point should be converted from subprogram DIE */
+        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+                                     pf->pev->point.retprobe, &tev->point);
         if (ret < 0)
                 return ret;
 
@@ -1091,7 +1148,8 @@ static int add_probe_trace_event(Dwarf_Die *sp_die, struct probe_finder *pf)
         for (i = 0; i < pf->pev->nargs; i++) {
                 pf->pvar = &pf->pev->args[i];
                 pf->tvar = &tev->args[i];
-                ret = find_variable(sp_die, pf);
+                /* Variable should be found from scope DIE */
+                ret = find_variable(sc_die, pf);
                 if (ret != 0)
                         return ret;
         }
@@ -1159,13 +1217,13 @@ static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
 }
 
 /* Add a found vars into available variables list */
-static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
+static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
 {
         struct available_var_finder *af =
                         container_of(pf, struct available_var_finder, pf);
         struct variable_list *vl;
-        Dwarf_Die die_mem, *scopes = NULL;
-        int ret, nscopes;
+        Dwarf_Die die_mem;
+        int ret;
 
         /* Check number of tevs */
         if (af->nvls == af->max_vls) {
@@ -1174,8 +1232,9 @@ static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
         }
         vl = &af->vls[af->nvls++];
 
-        ret = convert_to_trace_point(sp_die, pf->addr, pf->pev->point.retprobe,
-                                     &vl->point);
+        /* Trace point should be converted from subprogram DIE */
+        ret = convert_to_trace_point(&pf->sp_die, pf->addr,
+                                     pf->pev->point.retprobe, &vl->point);
         if (ret < 0)
                 return ret;
 
@@ -1187,19 +1246,14 @@ static int add_available_vars(Dwarf_Die *sp_die, struct probe_finder *pf)
         if (vl->vars == NULL)
                 return -ENOMEM;
         af->child = true;
-        die_find_child(sp_die, collect_variables_cb, (void *)af, &die_mem);
+        die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
 
         /* Find external variables */
         if (!af->externs)
                 goto out;
         /* Don't need to search child DIE for externs. */
         af->child = false;
-        nscopes = dwarf_getscopes_die(sp_die, &scopes);
-        while (nscopes-- > 1)
-                die_find_child(&scopes[nscopes], collect_variables_cb,
-                               (void *)af, &die_mem);
-        if (scopes)
-                free(scopes);
+        die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
 
 out:
         if (strlist__empty(vl->vars)) {
@@ -1391,10 +1445,14 @@ static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
 
 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
 {
-        struct dwarf_callback_param *param = data;
+        find_line_range_by_line(in_die, data);
 
-        param->retval = find_line_range_by_line(in_die, param->data);
-        return DWARF_CB_ABORT;  /* No need to find other instances */
+        /*
+         * We have to check all instances of inlined function, because
+         * some execution paths can be optimized out depends on the
+         * function argument of instances
+         */
+        return 0;
 }
 
 /* Search function from function name */
@@ -1422,15 +1480,10 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
                 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
                 lr->start = lf->lno_s;
                 lr->end = lf->lno_e;
-                if (dwarf_func_inline(sp_die)) {
-                        struct dwarf_callback_param _param;
-                        _param.data = (void *)lf;
-                        _param.retval = 0;
-                        dwarf_func_inline_instances(sp_die,
-                                                    line_range_inline_cb,
-                                                    &_param);
-                        param->retval = _param.retval;
-                } else
+                if (dwarf_func_inline(sp_die))
+                        param->retval = die_walk_instances(sp_die,
+                                                line_range_inline_cb, lf);
+                else
                         param->retval = find_line_range_by_line(sp_die, lf);
                 return DWARF_CB_ABORT;
         }
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index c478b42a2473..1132c8f0ce89 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -57,7 +57,7 @@ struct probe_finder {
         struct perf_probe_event *pev;           /* Target probe event */
 
         /* Callback when a probe point is found */
-        int (*callback)(Dwarf_Die *sp_die, struct probe_finder *pf);
+        int (*callback)(Dwarf_Die *sc_die, struct probe_finder *pf);
 
         /* For function searching */
         int                     lno;            /* Line number */
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 8e0b5a39d8a7..cbc8f215d4b7 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -187,16 +187,119 @@ static PyTypeObject pyrf_throttle_event__type = {
         .tp_repr        = (reprfunc)pyrf_throttle_event__repr,
 };
 
+static char pyrf_lost_event__doc[] = PyDoc_STR("perf lost event object.");
+
+static PyMemberDef pyrf_lost_event__members[] = {
+        sample_members
+        member_def(lost_event, id, T_ULONGLONG, "event id"),
+        member_def(lost_event, lost, T_ULONGLONG, "number of lost events"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_lost_event__repr(struct pyrf_event *pevent)
+{
+        PyObject *ret;
+        char *s;
+
+        if (asprintf(&s, "{ type: lost, id: %#" PRIx64 ", "
+                         "lost: %#" PRIx64 " }",
+                     pevent->event.lost.id, pevent->event.lost.lost) < 0) {
+                ret = PyErr_NoMemory();
+        } else {
+                ret = PyString_FromString(s);
+                free(s);
+        }
+        return ret;
+}
+
+static PyTypeObject pyrf_lost_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.lost_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_lost_event__doc,
+        .tp_members     = pyrf_lost_event__members,
+        .tp_repr        = (reprfunc)pyrf_lost_event__repr,
+};
+
+static char pyrf_read_event__doc[] = PyDoc_STR("perf read event object.");
+
+static PyMemberDef pyrf_read_event__members[] = {
+        sample_members
+        member_def(read_event, pid, T_UINT, "event pid"),
+        member_def(read_event, tid, T_UINT, "event tid"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_read_event__repr(struct pyrf_event *pevent)
+{
+        return PyString_FromFormat("{ type: read, pid: %u, tid: %u }",
+                                   pevent->event.read.pid,
+                                   pevent->event.read.tid);
+        /*
+         * FIXME: return the array of read values,
+         * making this method useful ;-)
+         */
+}
+
+static PyTypeObject pyrf_read_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.read_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_read_event__doc,
+        .tp_members     = pyrf_read_event__members,
+        .tp_repr        = (reprfunc)pyrf_read_event__repr,
+};
+
+static char pyrf_sample_event__doc[] = PyDoc_STR("perf sample event object.");
+
+static PyMemberDef pyrf_sample_event__members[] = {
+        sample_members
+        member_def(perf_event_header, type, T_UINT, "event type"),
+        { .name = NULL, },
+};
+
+static PyObject *pyrf_sample_event__repr(struct pyrf_event *pevent)
+{
+        PyObject *ret;
+        char *s;
+
+        if (asprintf(&s, "{ type: sample }") < 0) {
+                ret = PyErr_NoMemory();
+        } else {
+                ret = PyString_FromString(s);
+                free(s);
+        }
+        return ret;
+}
+
+static PyTypeObject pyrf_sample_event__type = {
+        PyVarObject_HEAD_INIT(NULL, 0)
+        .tp_name        = "perf.sample_event",
+        .tp_basicsize   = sizeof(struct pyrf_event),
+        .tp_flags       = Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
+        .tp_doc         = pyrf_sample_event__doc,
+        .tp_members     = pyrf_sample_event__members,
+        .tp_repr        = (reprfunc)pyrf_sample_event__repr,
+};
+
 static int pyrf_event__setup_types(void)
 {
         int err;
         pyrf_mmap_event__type.tp_new =
         pyrf_task_event__type.tp_new =
         pyrf_comm_event__type.tp_new =
+        pyrf_lost_event__type.tp_new =
+        pyrf_read_event__type.tp_new =
+        pyrf_sample_event__type.tp_new =
         pyrf_throttle_event__type.tp_new = PyType_GenericNew;
         err = PyType_Ready(&pyrf_mmap_event__type);
         if (err < 0)
                 goto out;
+        err = PyType_Ready(&pyrf_lost_event__type);
+        if (err < 0)
+                goto out;
         err = PyType_Ready(&pyrf_task_event__type);
         if (err < 0)
                 goto out;
@@ -206,20 +309,26 @@ static int pyrf_event__setup_types(void)
         err = PyType_Ready(&pyrf_throttle_event__type);
         if (err < 0)
                 goto out;
+        err = PyType_Ready(&pyrf_read_event__type);
+        if (err < 0)
+                goto out;
+        err = PyType_Ready(&pyrf_sample_event__type);
+        if (err < 0)
+                goto out;
 out:
         return err;
 }
 
 static PyTypeObject *pyrf_event__type[] = {
         [PERF_RECORD_MMAP]       = &pyrf_mmap_event__type,
-        [PERF_RECORD_LOST]       = &pyrf_mmap_event__type,
+        [PERF_RECORD_LOST]       = &pyrf_lost_event__type,
         [PERF_RECORD_COMM]       = &pyrf_comm_event__type,
         [PERF_RECORD_EXIT]       = &pyrf_task_event__type,
         [PERF_RECORD_THROTTLE]   = &pyrf_throttle_event__type,
         [PERF_RECORD_UNTHROTTLE] = &pyrf_throttle_event__type,
         [PERF_RECORD_FORK]       = &pyrf_task_event__type,
-        [PERF_RECORD_READ]       = &pyrf_mmap_event__type,
-        [PERF_RECORD_SAMPLE]     = &pyrf_mmap_event__type,
+        [PERF_RECORD_READ]       = &pyrf_read_event__type,
+        [PERF_RECORD_SAMPLE]     = &pyrf_sample_event__type,
 };
 
 static PyObject *pyrf_event__new(union perf_event *event)
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index bbc982f5dd8b..95d370074928 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -3,9 +3,27 @@
 from distutils.core import setup, Extension
 from os import getenv
 
+from distutils.command.build_ext   import build_ext   as _build_ext
+from distutils.command.install_lib import install_lib as _install_lib
+
+class build_ext(_build_ext):
+    def finalize_options(self):
+        _build_ext.finalize_options(self)
+        self.build_lib  = build_lib
+        self.build_temp = build_tmp
+
+class install_lib(_install_lib):
+    def finalize_options(self):
+        _install_lib.finalize_options(self)
+        self.build_dir = build_lib
+
+
 cflags = ['-fno-strict-aliasing', '-Wno-write-strings']
 cflags += getenv('CFLAGS', '').split()
 
+build_lib = getenv('PYTHON_EXTBUILD_LIB')
+build_tmp = getenv('PYTHON_EXTBUILD_TMP')
+
 perf = Extension('perf',
                   sources = ['util/python.c', 'util/ctype.c', 'util/evlist.c',
                              'util/evsel.c', 'util/cpumap.c', 'util/thread_map.c',
@@ -21,4 +39,5 @@ setup(name='perf',
       author_email='acme@redhat.com',
       license='GPLv2',
       url='http://perf.wiki.kernel.org',
-      ext_modules=[perf])
+      ext_modules=[perf],
+      cmdclass={'build_ext': build_ext, 'install_lib': install_lib})
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index eec196329fd9..469c0264ed29 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1504,6 +1504,17 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
         dso->adjust_symbols = 0;
 
         if (strncmp(dso->name, "/tmp/perf-", 10) == 0) {
+                struct stat st;
+
+                if (lstat(dso->name, &st) < 0)
+                        return -1;
+
+                if (st.st_uid && (st.st_uid != geteuid())) {
+                        pr_warning("File %s not owned by current user or root, "
+                                "ignoring it.\n", dso->name);
+                        return -1;
+                }
+
                 ret = dso__load_perf_map(dso, map, filter);
                 dso->symtab_type = ret > 0 ? SYMTAB__JAVA_JIT :
                                               SYMTAB__NOT_FOUND;
@@ -2170,27 +2181,22 @@ size_t machines__fprintf_dsos_buildid(struct rb_root *machines,
         return ret;
 }
 
-struct dso *dso__new_kernel(const char *name)
+static struct dso*
+dso__kernel_findnew(struct machine *machine, const char *name,
+                    const char *short_name, int dso_type)
 {
-        struct dso *dso = dso__new(name ?: "[kernel.kallsyms]");
-
-        if (dso != NULL) {
-                dso__set_short_name(dso, "[kernel]");
-                dso->kernel = DSO_TYPE_KERNEL;
-        }
-
-        return dso;
-}
+        /*
+         * The kernel dso could be created by build_id processing.
+         */
+        struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
 
-static struct dso *dso__new_guest_kernel(struct machine *machine,
-                                        const char *name)
-{
-        char bf[PATH_MAX];
-        struct dso *dso = dso__new(name ?: machine__mmap_name(machine, bf,
-                                                              sizeof(bf)));
+        /*
+         * We need to run this in all cases, since during the build_id
+         * processing we had no idea this was the kernel dso.
+         */
         if (dso != NULL) {
-                dso__set_short_name(dso, "[guest.kernel]");
-                dso->kernel = DSO_TYPE_GUEST_KERNEL;
+                dso__set_short_name(dso, short_name);
+                dso->kernel = dso_type;
         }
 
         return dso;
@@ -2208,24 +2214,36 @@ void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
                 dso->has_build_id = true;
 }
 
-static struct dso *machine__create_kernel(struct machine *machine)
+static struct dso *machine__get_kernel(struct machine *machine)
 {
         const char *vmlinux_name = NULL;
         struct dso *kernel;
 
         if (machine__is_host(machine)) {
                 vmlinux_name = symbol_conf.vmlinux_name;
-                kernel = dso__new_kernel(vmlinux_name);
+                if (!vmlinux_name)
+                        vmlinux_name = "[kernel.kallsyms]";
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[kernel]",
+                                             DSO_TYPE_KERNEL);
         } else {
+                char bf[PATH_MAX];
+
                 if (machine__is_default_guest(machine))
                         vmlinux_name = symbol_conf.default_guest_vmlinux_name;
-                kernel = dso__new_guest_kernel(machine, vmlinux_name);
+                if (!vmlinux_name)
+                        vmlinux_name = machine__mmap_name(machine, bf,
+                                                          sizeof(bf));
+
+                kernel = dso__kernel_findnew(machine, vmlinux_name,
+                                             "[guest.kernel]",
+                                             DSO_TYPE_GUEST_KERNEL);
         }
 
-        if (kernel != NULL) {
+        if (kernel != NULL && (!kernel->has_build_id))
                 dso__read_running_kernel_build_id(kernel, machine);
-                dsos__add(&machine->kernel_dsos, kernel);
-        }
+
         return kernel;
 }
 
@@ -2329,7 +2347,7 @@ void machine__destroy_kernel_maps(struct machine *machine)
 
 int machine__create_kernel_maps(struct machine *machine)
 {
-        struct dso *kernel = machine__create_kernel(machine);
+        struct dso *kernel = machine__get_kernel(machine);
 
         if (kernel == NULL ||
             __machine__create_kernel_maps(machine, kernel) < 0)
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 325ee36a9d29..4f377d92e75a 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -155,7 +155,6 @@ struct dso {
 };
 
 struct dso *dso__new(const char *name);
-struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *dso);
 
 int dso__name_len(const struct dso *dso);
diff --git a/tools/perf/util/ui/browsers/top.c b/tools/perf/util/ui/browsers/top.c
index 5a06538532af..88403cf8396a 100644
--- a/tools/perf/util/ui/browsers/top.c
+++ b/tools/perf/util/ui/browsers/top.c
@@ -208,6 +208,5 @@ int perf_top__tui_browser(struct perf_top *top)
                 },
         };
 
-        ui_helpline__push("Press <- or ESC to exit");
         return perf_top_browser__run(&browser);
 }