9 files changed, 263 insertions, 165 deletions

diff --git a/kernel/events/core.c b/kernel/events/core.c
index 9efe7108ccaf..ba89f40abe6a 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -200,6 +200,22 @@ __get_cpu_context(struct perf_event_context *ctx)
         return this_cpu_ptr(ctx->pmu->pmu_cpu_context);
 }
 
+static void perf_ctx_lock(struct perf_cpu_context *cpuctx,
+                          struct perf_event_context *ctx)
+{
+        raw_spin_lock(&cpuctx->ctx.lock);
+        if (ctx)
+                raw_spin_lock(&ctx->lock);
+}
+
+static void perf_ctx_unlock(struct perf_cpu_context *cpuctx,
+                            struct perf_event_context *ctx)
+{
+        if (ctx)
+                raw_spin_unlock(&ctx->lock);
+        raw_spin_unlock(&cpuctx->ctx.lock);
+}
+
 #ifdef CONFIG_CGROUP_PERF
 
 /*
@@ -340,11 +356,8 @@ void perf_cgroup_switch(struct task_struct *task, int mode)
         rcu_read_lock();
 
         list_for_each_entry_rcu(pmu, &pmus, entry) {
-
                 cpuctx = this_cpu_ptr(pmu->pmu_cpu_context);
 
-                perf_pmu_disable(cpuctx->ctx.pmu);
-
                 /*
                  * perf_cgroup_events says at least one
                  * context on this CPU has cgroup events.
@@ -353,6 +366,8 @@ void perf_cgroup_switch(struct task_struct *task, int mode)
                  * events for a context.
                  */
                 if (cpuctx->ctx.nr_cgroups > 0) {
+                        perf_ctx_lock(cpuctx, cpuctx->task_ctx);
+                        perf_pmu_disable(cpuctx->ctx.pmu);
 
                         if (mode & PERF_CGROUP_SWOUT) {
                                 cpu_ctx_sched_out(cpuctx, EVENT_ALL);
@@ -372,9 +387,9 @@ void perf_cgroup_switch(struct task_struct *task, int mode)
                                 cpuctx->cgrp = perf_cgroup_from_task(task);
                                 cpu_ctx_sched_in(cpuctx, EVENT_ALL, task);
                         }
+                        perf_pmu_enable(cpuctx->ctx.pmu);
+                        perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
                 }
-
-                perf_pmu_enable(cpuctx->ctx.pmu);
         }
 
         rcu_read_unlock();
@@ -1105,6 +1120,10 @@ static int __perf_remove_from_context(void *info)
         raw_spin_lock(&ctx->lock);
         event_sched_out(event, cpuctx, ctx);
         list_del_event(event, ctx);
+        if (!ctx->nr_events && cpuctx->task_ctx == ctx) {
+                ctx->is_active = 0;
+                cpuctx->task_ctx = NULL;
+        }
         raw_spin_unlock(&ctx->lock);
 
         return 0;
@@ -1454,8 +1473,24 @@ static void add_event_to_ctx(struct perf_event *event,
         event->tstamp_stopped = tstamp;
 }
 
-static void perf_event_context_sched_in(struct perf_event_context *ctx,
-                                        struct task_struct *tsk);
+static void task_ctx_sched_out(struct perf_event_context *ctx);
+static void
+ctx_sched_in(struct perf_event_context *ctx,
+             struct perf_cpu_context *cpuctx,
+             enum event_type_t event_type,
+             struct task_struct *task);
+
+static void perf_event_sched_in(struct perf_cpu_context *cpuctx,
+                                struct perf_event_context *ctx,
+                                struct task_struct *task)
+{
+        cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
+        if (ctx)
+                ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
+        cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
+        if (ctx)
+                ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
+}
 
 /*
  * Cross CPU call to install and enable a performance event
@@ -1466,20 +1501,31 @@ static int  __perf_install_in_context(void *info)
 {
         struct perf_event *event = info;
         struct perf_event_context *ctx = event->ctx;
-        struct perf_event *leader = event->group_leader;
         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
-        int err;
+        struct perf_event_context *task_ctx = cpuctx->task_ctx;
+        struct task_struct *task = current;
+
+        perf_ctx_lock(cpuctx, cpuctx->task_ctx);
+        perf_pmu_disable(cpuctx->ctx.pmu);
 
         /*
-         * In case we're installing a new context to an already running task,
-         * could also happen before perf_event_task_sched_in() on architectures
-         * which do context switches with IRQs enabled.
+         * If there was an active task_ctx schedule it out.
          */
-        if (ctx->task && !cpuctx->task_ctx)
-                perf_event_context_sched_in(ctx, ctx->task);
+        if (task_ctx) {
+                task_ctx_sched_out(task_ctx);
+                /*
+                 * If the context we're installing events in is not the
+                 * active task_ctx, flip them.
+                 */
+                if (ctx->task && task_ctx != ctx) {
+                        raw_spin_unlock(&cpuctx->ctx.lock);
+                        raw_spin_lock(&ctx->lock);
+                        cpuctx->task_ctx = task_ctx = ctx;
+                }
+                task = task_ctx->task;
+        }
+        cpu_ctx_sched_out(cpuctx, EVENT_ALL);
 
-        raw_spin_lock(&ctx->lock);
-        ctx->is_active = 1;
         update_context_time(ctx);
         /*
          * update cgrp time only if current cgrp
@@ -1490,43 +1536,13 @@ static int  __perf_install_in_context(void *info)
 
         add_event_to_ctx(event, ctx);
 
-        if (!event_filter_match(event))
-                goto unlock;
-
-        /*
-         * Don't put the event on if it is disabled or if
-         * it is in a group and the group isn't on.
-         */
-        if (event->state != PERF_EVENT_STATE_INACTIVE ||
-            (leader != event && leader->state != PERF_EVENT_STATE_ACTIVE))
-                goto unlock;
-
         /*
-         * An exclusive event can't go on if there are already active
-         * hardware events, and no hardware event can go on if there
-         * is already an exclusive event on.
+         * Schedule everything back in
          */
-        if (!group_can_go_on(event, cpuctx, 1))
-                err = -EEXIST;
-        else
-                err = event_sched_in(event, cpuctx, ctx);
+        perf_event_sched_in(cpuctx, task_ctx, task);
 
-        if (err) {
-                /*
-                 * This event couldn't go on.  If it is in a group
-                 * then we have to pull the whole group off.
-                 * If the event group is pinned then put it in error state.
-                 */
-                if (leader != event)
-                        group_sched_out(leader, cpuctx, ctx);
-                if (leader->attr.pinned) {
-                        update_group_times(leader);
-                        leader->state = PERF_EVENT_STATE_ERROR;
-                }
-        }
-
-unlock:
-        raw_spin_unlock(&ctx->lock);
+        perf_pmu_enable(cpuctx->ctx.pmu);
+        perf_ctx_unlock(cpuctx, task_ctx);
 
         return 0;
 }
@@ -1758,30 +1774,28 @@ static void ctx_sched_out(struct perf_event_context *ctx,
                           enum event_type_t event_type)
 {
         struct perf_event *event;
+        int is_active = ctx->is_active;
 
-        raw_spin_lock(&ctx->lock);
-        perf_pmu_disable(ctx->pmu);
-        ctx->is_active = 0;
+        ctx->is_active &= ~event_type;
         if (likely(!ctx->nr_events))
-                goto out;
+                return;
+
         update_context_time(ctx);
         update_cgrp_time_from_cpuctx(cpuctx);
-
         if (!ctx->nr_active)
-                goto out;
+                return;
 
-        if (event_type & EVENT_PINNED) {
+        perf_pmu_disable(ctx->pmu);
+        if ((is_active & EVENT_PINNED) && (event_type & EVENT_PINNED)) {
                 list_for_each_entry(event, &ctx->pinned_groups, group_entry)
                         group_sched_out(event, cpuctx, ctx);
         }
 
-        if (event_type & EVENT_FLEXIBLE) {
+        if ((is_active & EVENT_FLEXIBLE) && (event_type & EVENT_FLEXIBLE)) {
                 list_for_each_entry(event, &ctx->flexible_groups, group_entry)
                         group_sched_out(event, cpuctx, ctx);
         }
-out:
         perf_pmu_enable(ctx->pmu);
-        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -1929,8 +1943,10 @@ static void perf_event_context_sched_out(struct task_struct *task, int ctxn,
         rcu_read_unlock();
 
         if (do_switch) {
+                raw_spin_lock(&ctx->lock);
                 ctx_sched_out(ctx, cpuctx, EVENT_ALL);
                 cpuctx->task_ctx = NULL;
+                raw_spin_unlock(&ctx->lock);
         }
 }
 
@@ -1965,8 +1981,7 @@ void __perf_event_task_sched_out(struct task_struct *task,
                 perf_cgroup_sched_out(task);
 }
 
-static void task_ctx_sched_out(struct perf_event_context *ctx,
-                               enum event_type_t event_type)
+static void task_ctx_sched_out(struct perf_event_context *ctx)
 {
         struct perf_cpu_context *cpuctx = __get_cpu_context(ctx);
 
@@ -1976,7 +1991,7 @@ static void task_ctx_sched_out(struct perf_event_context *ctx,
         if (WARN_ON_ONCE(ctx != cpuctx->task_ctx))
                 return;
 
-        ctx_sched_out(ctx, cpuctx, event_type);
+        ctx_sched_out(ctx, cpuctx, EVENT_ALL);
         cpuctx->task_ctx = NULL;
 }
 
@@ -2055,11 +2070,11 @@ ctx_sched_in(struct perf_event_context *ctx,
              struct task_struct *task)
 {
         u64 now;
+        int is_active = ctx->is_active;
 
-        raw_spin_lock(&ctx->lock);
-        ctx->is_active = 1;
+        ctx->is_active |= event_type;
         if (likely(!ctx->nr_events))
-                goto out;
+                return;
 
         now = perf_clock();
         ctx->timestamp = now;
@@ -2068,15 +2083,12 @@ ctx_sched_in(struct perf_event_context *ctx,
          * First go through the list and put on any pinned groups
          * in order to give them the best chance of going on.
          */
-        if (event_type & EVENT_PINNED)
+        if (!(is_active & EVENT_PINNED) && (event_type & EVENT_PINNED))
                 ctx_pinned_sched_in(ctx, cpuctx);
 
         /* Then walk through the lower prio flexible groups */
-        if (event_type & EVENT_FLEXIBLE)
+        if (!(is_active & EVENT_FLEXIBLE) && (event_type & EVENT_FLEXIBLE))
                 ctx_flexible_sched_in(ctx, cpuctx);
-
-out:
-        raw_spin_unlock(&ctx->lock);
 }
 
 static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
@@ -2088,19 +2100,6 @@ static void cpu_ctx_sched_in(struct perf_cpu_context *cpuctx,
         ctx_sched_in(ctx, cpuctx, event_type, task);
 }
 
-static void task_ctx_sched_in(struct perf_event_context *ctx,
-                              enum event_type_t event_type)
-{
-        struct perf_cpu_context *cpuctx;
-
-        cpuctx = __get_cpu_context(ctx);
-        if (cpuctx->task_ctx == ctx)
-                return;
-
-        ctx_sched_in(ctx, cpuctx, event_type, NULL);
-        cpuctx->task_ctx = ctx;
-}
-
 static void perf_event_context_sched_in(struct perf_event_context *ctx,
                                         struct task_struct *task)
 {
@@ -2110,6 +2109,7 @@ static void perf_event_context_sched_in(struct perf_event_context *ctx,
         if (cpuctx->task_ctx == ctx)
                 return;
 
+        perf_ctx_lock(cpuctx, ctx);
         perf_pmu_disable(ctx->pmu);
         /*
          * We want to keep the following priority order:
@@ -2118,18 +2118,18 @@ static void perf_event_context_sched_in(struct perf_event_context *ctx,
          */
         cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
 
-        ctx_sched_in(ctx, cpuctx, EVENT_PINNED, task);
-        cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
-        ctx_sched_in(ctx, cpuctx, EVENT_FLEXIBLE, task);
+        perf_event_sched_in(cpuctx, ctx, task);
 
         cpuctx->task_ctx = ctx;
 
+        perf_pmu_enable(ctx->pmu);
+        perf_ctx_unlock(cpuctx, ctx);
+
         /*
          * Since these rotations are per-cpu, we need to ensure the
          * cpu-context we got scheduled on is actually rotating.
          */
         perf_pmu_rotate_start(ctx->pmu);
-        perf_pmu_enable(ctx->pmu);
 }
 
 /*
@@ -2269,7 +2269,6 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
         u64 interrupts, now;
         s64 delta;
 
-        raw_spin_lock(&ctx->lock);
         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
                 if (event->state != PERF_EVENT_STATE_ACTIVE)
                         continue;
@@ -2301,7 +2300,6 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
                 if (delta > 0)
                         perf_adjust_period(event, period, delta);
         }
-        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -2309,16 +2307,12 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx, u64 period)
  */
 static void rotate_ctx(struct perf_event_context *ctx)
 {
-        raw_spin_lock(&ctx->lock);
-
         /*
          * Rotate the first entry last of non-pinned groups. Rotation might be
          * disabled by the inheritance code.
          */
         if (!ctx->rotate_disable)
                 list_rotate_left(&ctx->flexible_groups);
-
-        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -2345,6 +2339,7 @@ static void perf_rotate_context(struct perf_cpu_context *cpuctx)
                         rotate = 1;
         }
 
+        perf_ctx_lock(cpuctx, cpuctx->task_ctx);
         perf_pmu_disable(cpuctx->ctx.pmu);
         perf_ctx_adjust_freq(&cpuctx->ctx, interval);
         if (ctx)
@@ -2355,21 +2350,20 @@ static void perf_rotate_context(struct perf_cpu_context *cpuctx)
 
         cpu_ctx_sched_out(cpuctx, EVENT_FLEXIBLE);
         if (ctx)
-                task_ctx_sched_out(ctx, EVENT_FLEXIBLE);
+                ctx_sched_out(ctx, cpuctx, EVENT_FLEXIBLE);
 
         rotate_ctx(&cpuctx->ctx);
         if (ctx)
                 rotate_ctx(ctx);
 
-        cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, current);
-        if (ctx)
-                task_ctx_sched_in(ctx, EVENT_FLEXIBLE);
+        perf_event_sched_in(cpuctx, ctx, current);
 
 done:
         if (remove)
                 list_del_init(&cpuctx->rotation_list);
 
         perf_pmu_enable(cpuctx->ctx.pmu);
+        perf_ctx_unlock(cpuctx, cpuctx->task_ctx);
 }
 
 void perf_event_task_tick(void)
@@ -2424,9 +2418,9 @@ static void perf_event_enable_on_exec(struct perf_event_context *ctx)
          * in.
          */
         perf_cgroup_sched_out(current);
-        task_ctx_sched_out(ctx, EVENT_ALL);
 
         raw_spin_lock(&ctx->lock);
+        task_ctx_sched_out(ctx);
 
         list_for_each_entry(event, &ctx->pinned_groups, group_entry) {
                 ret = event_enable_on_exec(event, ctx);
@@ -2835,16 +2829,12 @@ retry:
                 unclone_ctx(ctx);
                 ++ctx->pin_count;
                 raw_spin_unlock_irqrestore(&ctx->lock, flags);
-        }
-
-        if (!ctx) {
+        } else {
                 ctx = alloc_perf_context(pmu, task);
                 err = -ENOMEM;
                 if (!ctx)
                         goto errout;
 
-                get_ctx(ctx);
-
                 err = 0;
                 mutex_lock(&task->perf_event_mutex);
                 /*
@@ -2856,14 +2846,14 @@ retry:
                 else if (task->perf_event_ctxp[ctxn])
                         err = -EAGAIN;
                 else {
+                        get_ctx(ctx);
                         ++ctx->pin_count;
                         rcu_assign_pointer(task->perf_event_ctxp[ctxn], ctx);
                 }
                 mutex_unlock(&task->perf_event_mutex);
 
                 if (unlikely(err)) {
-                        put_task_struct(task);
-                        kfree(ctx);
+                        put_ctx(ctx);
 
                         if (err == -EAGAIN)
                                 goto retry;
@@ -2934,12 +2924,6 @@ int perf_event_release_kernel(struct perf_event *event)
 {
         struct perf_event_context *ctx = event->ctx;
 
-        /*
-         * Remove from the PMU, can't get re-enabled since we got
-         * here because the last ref went.
-         */
-        perf_event_disable(event);
-
         WARN_ON_ONCE(ctx->parent_ctx);
         /*
          * There are two ways this annotation is useful:
@@ -2956,8 +2940,8 @@ int perf_event_release_kernel(struct perf_event *event)
         mutex_lock_nested(&ctx->mutex, SINGLE_DEPTH_NESTING);
         raw_spin_lock_irq(&ctx->lock);
         perf_group_detach(event);
-        list_del_event(event, ctx);
         raw_spin_unlock_irq(&ctx->lock);
+        perf_remove_from_context(event);
         mutex_unlock(&ctx->mutex);
 
         free_event(event);
@@ -5986,6 +5970,7 @@ free_dev:
 }
 
 static struct lock_class_key cpuctx_mutex;
+static struct lock_class_key cpuctx_lock;
 
 int perf_pmu_register(struct pmu *pmu, char *name, int type)
 {
@@ -6036,6 +6021,7 @@ skip_type:
                 cpuctx = per_cpu_ptr(pmu->pmu_cpu_context, cpu);
                 __perf_event_init_context(&cpuctx->ctx);
                 lockdep_set_class(&cpuctx->ctx.mutex, &cpuctx_mutex);
+                lockdep_set_class(&cpuctx->ctx.lock, &cpuctx_lock);
                 cpuctx->ctx.type = cpu_context;
                 cpuctx->ctx.pmu = pmu;
                 cpuctx->jiffies_interval = 1;
@@ -6780,7 +6766,6 @@ static void perf_event_exit_task_context(struct task_struct *child, int ctxn)
          * our context.
          */
         child_ctx = rcu_dereference_raw(child->perf_event_ctxp[ctxn]);
-        task_ctx_sched_out(child_ctx, EVENT_ALL);
 
         /*
          * Take the context lock here so that if find_get_context is
@@ -6788,6 +6773,7 @@ static void perf_event_exit_task_context(struct task_struct *child, int ctxn)
          * incremented the context's refcount before we do put_ctx below.
          */
         raw_spin_lock(&child_ctx->lock);
+        task_ctx_sched_out(child_ctx);
         child->perf_event_ctxp[ctxn] = NULL;
         /*
          * If this context is a clone; unclone it so it can't get
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index 86c87e214b11..c6068cb43f57 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -115,10 +115,10 @@ OPTIONS
 -f::
 --fields::
         Comma separated list of fields to print. Options are:
-        comm, tid, pid, time, cpu, event, trace, sym. Field
-        list can be prepended with the type, trace, sw or hw,
+        comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr.
+        Field list can be prepended with the type, trace, sw or hw,
         to indicate to which event type the field list applies.
-        e.g., -f sw:comm,tid,time,sym  and -f trace:time,cpu,trace
+        e.g., -f sw:comm,tid,time,ip,sym  and -f trace:time,cpu,trace
 
                 perf script -f <fields>
 
@@ -132,17 +132,17 @@ OPTIONS
         The arguments are processed in the order received. A later usage can
         reset a prior request. e.g.:
     
-                -f trace: -f comm,tid,time,sym
+                -f trace: -f comm,tid,time,ip,sym
     
         The first -f suppresses trace events (field list is ""), but then the
-        second invocation sets the fields to comm,tid,time,sym. In this case a
+        second invocation sets the fields to comm,tid,time,ip,sym. In this case a
         warning is given to the user:
     
                 "Overriding previous field request for all events."
     
         Alternativey, consider the order:
     
-                -f comm,tid,time,sym -f trace:
+                -f comm,tid,time,ip,sym -f trace:
     
         The first -f sets the fields for all events and the second -f
         suppresses trace events. The user is given a warning message about
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index 22747de7234b..3056b45b3dd6 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -30,7 +30,10 @@ enum perf_output_field {
         PERF_OUTPUT_CPU             = 1U << 4,
         PERF_OUTPUT_EVNAME          = 1U << 5,
         PERF_OUTPUT_TRACE           = 1U << 6,
-        PERF_OUTPUT_SYM             = 1U << 7,
+        PERF_OUTPUT_IP              = 1U << 7,
+        PERF_OUTPUT_SYM             = 1U << 8,
+        PERF_OUTPUT_DSO             = 1U << 9,
+        PERF_OUTPUT_ADDR            = 1U << 10,
 };
 
 struct output_option {
@@ -44,7 +47,10 @@ struct output_option {
         {.str = "cpu",   .field = PERF_OUTPUT_CPU},
         {.str = "event", .field = PERF_OUTPUT_EVNAME},
         {.str = "trace", .field = PERF_OUTPUT_TRACE},
+        {.str = "ip",    .field = PERF_OUTPUT_IP},
         {.str = "sym",   .field = PERF_OUTPUT_SYM},
+        {.str = "dso",   .field = PERF_OUTPUT_DSO},
+        {.str = "addr",  .field = PERF_OUTPUT_ADDR},
 };
 
 /* default set to maintain compatibility with current format */
@@ -60,7 +66,8 @@ static struct {
 
                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
-                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_SYM,
+                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
                 .invalid_fields = PERF_OUTPUT_TRACE,
         },
@@ -70,7 +77,8 @@ static struct {
 
                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
-                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_SYM,
+                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
                 .invalid_fields = PERF_OUTPUT_TRACE,
         },
@@ -88,7 +96,8 @@ static struct {
 
                 .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
                               PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
-                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_SYM,
+                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                                  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
                 .invalid_fields = PERF_OUTPUT_TRACE,
         },
@@ -157,9 +166,9 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                 !perf_session__has_traces(session, "record -R"))
                 return -EINVAL;
 
-        if (PRINT_FIELD(SYM)) {
+        if (PRINT_FIELD(IP)) {
                 if (perf_event_attr__check_stype(attr, PERF_SAMPLE_IP, "IP",
-                                           PERF_OUTPUT_SYM))
+                                           PERF_OUTPUT_IP))
                         return -EINVAL;
 
                 if (!no_callchain &&
@@ -167,6 +176,24 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                         symbol_conf.use_callchain = false;
         }
 
+        if (PRINT_FIELD(ADDR) &&
+                perf_event_attr__check_stype(attr, PERF_SAMPLE_ADDR, "ADDR",
+                                       PERF_OUTPUT_ADDR))
+                return -EINVAL;
+
+        if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+                pr_err("Display of symbols requested but neither sample IP nor "
+                           "sample address\nis selected. Hence, no addresses to convert "
+                       "to symbols.\n");
+                return -EINVAL;
+        }
+        if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
+                pr_err("Display of DSO requested but neither sample IP nor "
+                           "sample address\nis selected. Hence, no addresses to convert "
+                       "to DSO.\n");
+                return -EINVAL;
+        }
+
         if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
                 perf_event_attr__check_stype(attr, PERF_SAMPLE_TID, "TID",
                                        PERF_OUTPUT_TID|PERF_OUTPUT_PID))
@@ -230,7 +257,7 @@ static void print_sample_start(struct perf_sample *sample,
         if (PRINT_FIELD(COMM)) {
                 if (latency_format)
                         printf("%8.8s ", thread->comm);
-                else if (PRINT_FIELD(SYM) && symbol_conf.use_callchain)
+                else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
                         printf("%s ", thread->comm);
                 else
                         printf("%16s ", thread->comm);
@@ -271,6 +298,63 @@ static void print_sample_start(struct perf_sample *sample,
         }
 }
 
+static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
+{
+        if ((attr->type == PERF_TYPE_SOFTWARE) &&
+            ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
+             (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
+             (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
+                return true;
+
+        return false;
+}
+
+static void print_sample_addr(union perf_event *event,
+                          struct perf_sample *sample,
+                          struct perf_session *session,
+                          struct thread *thread,
+                          struct perf_event_attr *attr)
+{
+        struct addr_location al;
+        u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+        const char *symname, *dsoname;
+
+        printf("%16" PRIx64, sample->addr);
+
+        if (!sample_addr_correlates_sym(attr))
+                return;
+
+        thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION,
+                              event->ip.pid, sample->addr, &al);
+        if (!al.map)
+                thread__find_addr_map(thread, session, cpumode, MAP__VARIABLE,
+                                      event->ip.pid, sample->addr, &al);
+
+        al.cpu = sample->cpu;
+        al.sym = NULL;
+
+        if (al.map)
+                al.sym = map__find_symbol(al.map, al.addr, NULL);
+
+        if (PRINT_FIELD(SYM)) {
+                if (al.sym && al.sym->name)
+                        symname = al.sym->name;
+                else
+                        symname = "";
+
+                printf(" %16s", symname);
+        }
+
+        if (PRINT_FIELD(DSO)) {
+                if (al.map && al.map->dso && al.map->dso->name)
+                        dsoname = al.map->dso->name;
+                else
+                        dsoname = "";
+
+                printf(" (%s)", dsoname);
+        }
+}
+
 static void process_event(union perf_event *event __unused,
                           struct perf_sample *sample,
                           struct perf_evsel *evsel,
@@ -288,12 +372,16 @@ static void process_event(union perf_event *event __unused,
                 print_trace_event(sample->cpu, sample->raw_data,
                                   sample->raw_size);
 
-        if (PRINT_FIELD(SYM)) {
+        if (PRINT_FIELD(ADDR))
+                print_sample_addr(event, sample, session, thread, attr);
+
+        if (PRINT_FIELD(IP)) {
                 if (!symbol_conf.use_callchain)
                         printf(" ");
                 else
                         printf("\n");
-                perf_session__print_symbols(event, sample, session);
+                perf_session__print_ip(event, sample, session,
+                                              PRINT_FIELD(SYM), PRINT_FIELD(DSO));
         }
 
         printf("\n");
@@ -985,7 +1073,7 @@ static const struct option options[] = {
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                     "Look for files with symbols relative to this directory"),
         OPT_CALLBACK('f', "fields", NULL, "str",
-                     "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace,raw. Fields: comm,tid,pid,time,cpu,event,trace,sym",
+                     "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace,raw. Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,addr",
                      parse_output_fields),
 
         OPT_END()
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index a9f06715e44d..784ed6d6e0d6 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -61,6 +61,8 @@
 #include <locale.h>
 
 #define DEFAULT_SEPARATOR       " "
+#define CNTR_NOT_SUPPORTED      "<not supported>"
+#define CNTR_NOT_COUNTED        "<not counted>"
 
 static struct perf_event_attr default_attrs[] = {
 
@@ -448,6 +450,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                                 if (verbose)
                                         ui__warning("%s event is not supported by the kernel.\n",
                                                     event_name(counter));
+                                counter->supported = false;
                                 continue;
                         }
 
@@ -466,6 +469,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                         die("Not all events could be opened.\n");
                         return -1;
                 }
+                counter->supported = true;
         }
 
         if (perf_evlist__set_filters(evsel_list)) {
@@ -861,7 +865,7 @@ static void print_counter_aggr(struct perf_evsel *counter)
         if (scaled == -1) {
                 fprintf(stderr, "%*s%s%*s",
                         csv_output ? 0 : 18,
-                        "<not counted>",
+                        counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
                         csv_sep,
                         csv_output ? 0 : -24,
                         event_name(counter));
@@ -914,7 +918,8 @@ static void print_counter(struct perf_evsel *counter)
                                 csv_output ? 0 : -4,
                                 evsel_list->cpus->map[cpu], csv_sep,
                                 csv_output ? 0 : 18,
-                                "<not counted>", csv_sep,
+                                counter->supported ? CNTR_NOT_COUNTED : CNTR_NOT_SUPPORTED,
+                                csv_sep,
                                 csv_output ? 0 : -24,
                                 event_name(counter));
 
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 0239eb87b232..a03a36b7908a 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -377,6 +377,7 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
                 array++;
         }
 
+        data->addr = 0;
         if (type & PERF_SAMPLE_ADDR) {
                 data->addr = *array;
                 array++;
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 7e9366e4490b..e9a31554e265 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -61,6 +61,7 @@ struct perf_evsel {
                 off_t           id_offset;
         };
         struct cgroup_sel       *cgrp;
+        bool                    supported;
 };
 
 struct cpu_map;
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index a9ac0504aabd..8e0b5a39d8a7 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -247,7 +247,7 @@ struct pyrf_cpu_map {
 static int pyrf_cpu_map__init(struct pyrf_cpu_map *pcpus,
                               PyObject *args, PyObject *kwargs)
 {
-        static char *kwlist[] = { "cpustr", NULL, NULL, };
+        static char *kwlist[] = { "cpustr", NULL };
         char *cpustr = NULL;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s",
@@ -316,7 +316,7 @@ struct pyrf_thread_map {
 static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads,
                                  PyObject *args, PyObject *kwargs)
 {
-        static char *kwlist[] = { "pid", "tid", NULL, NULL, };
+        static char *kwlist[] = { "pid", "tid", NULL };
         int pid = -1, tid = -1;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii",
@@ -418,7 +418,9 @@ static int pyrf_evsel__init(struct pyrf_evsel *pevsel,
                 "wakeup_events",
                 "bp_type",
                 "bp_addr",
-                "bp_len", NULL, NULL, };
+                "bp_len",
+                 NULL
+        };
         u64 sample_period = 0;
         u32 disabled = 0,
             inherit = 0,
@@ -499,7 +501,7 @@ static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel,
         struct thread_map *threads = NULL;
         PyObject *pcpus = NULL, *pthreads = NULL;
         int group = 0, inherit = 0;
-        static char *kwlist[] = {"cpus", "threads", "group", "inherit", NULL, NULL};
+        static char *kwlist[] = { "cpus", "threads", "group", "inherit", NULL };
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist,
                                          &pcpus, &pthreads, &group, &inherit))
@@ -582,8 +584,7 @@ static PyObject *pyrf_evlist__mmap(struct pyrf_evlist *pevlist,
                                    PyObject *args, PyObject *kwargs)
 {
         struct perf_evlist *evlist = &pevlist->evlist;
-        static char *kwlist[] = {"pages", "overwrite",
-                                  NULL, NULL};
+        static char *kwlist[] = { "pages", "overwrite", NULL };
         int pages = 128, overwrite = false;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii", kwlist,
@@ -603,7 +604,7 @@ static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist,
                                    PyObject *args, PyObject *kwargs)
 {
         struct perf_evlist *evlist = &pevlist->evlist;
-        static char *kwlist[] = {"timeout", NULL, NULL};
+        static char *kwlist[] = { "timeout", NULL };
         int timeout = -1, n;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|i", kwlist, &timeout))
@@ -674,7 +675,7 @@ static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
         struct perf_evlist *evlist = &pevlist->evlist;
         union perf_event *event;
         int sample_id_all = 1, cpu;
-        static char *kwlist[] = {"cpu", "sample_id_all", NULL, NULL};
+        static char *kwlist[] = { "cpu", "sample_id_all", NULL };
         int err;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "i|i", kwlist,
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index f5a8fbdd3f76..b723f211881c 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -708,9 +708,9 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
         if (!dump_trace)
                 return;
 
-        printf("(IP, %d): %d/%d: %#" PRIx64 " period: %" PRIu64 "\n",
+        printf("(IP, %d): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
                event->header.misc, sample->pid, sample->tid, sample->ip,
-               sample->period);
+               sample->period, sample->addr);
 
         if (session->sample_type & PERF_SAMPLE_CALLCHAIN)
                 callchain__printf(sample);
@@ -1202,9 +1202,10 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
         return NULL;
 }
 
-void perf_session__print_symbols(union perf_event *event,
-                                struct perf_sample *sample,
-                                struct perf_session *session)
+void perf_session__print_ip(union perf_event *event,
+                            struct perf_sample *sample,
+                            struct perf_session *session,
+                            int print_sym, int print_dso)
 {
         struct addr_location al;
         const char *symname, *dsoname;
@@ -1233,32 +1234,46 @@ void perf_session__print_symbols(union perf_event *event,
                         if (!node)
                                 break;
 
-                        if (node->sym && node->sym->name)
-                                symname = node->sym->name;
-                        else
-                                symname = "";
+                        printf("\t%16" PRIx64, node->ip);
+                        if (print_sym) {
+                                if (node->sym && node->sym->name)
+                                        symname = node->sym->name;
+                                else
+                                        symname = "";
 
-                        if (node->map && node->map->dso && node->map->dso->name)
-                                dsoname = node->map->dso->name;
-                        else
-                                dsoname = "";
+                                printf(" %s", symname);
+                        }
+                        if (print_dso) {
+                                if (node->map && node->map->dso && node->map->dso->name)
+                                        dsoname = node->map->dso->name;
+                                else
+                                        dsoname = "";
 
-                        printf("\t%16" PRIx64 " %s (%s)\n", node->ip, symname, dsoname);
+                                printf(" (%s)", dsoname);
+                        }
+                        printf("\n");
 
                         callchain_cursor_advance(cursor);
                 }
 
         } else {
-                if (al.sym && al.sym->name)
-                        symname = al.sym->name;
-                else
-                        symname = "";
+                printf("%16" PRIx64, al.addr);
+                if (print_sym) {
+                        if (al.sym && al.sym->name)
+                                symname = al.sym->name;
+                        else
+                                symname = "";
 
-                if (al.map && al.map->dso && al.map->dso->name)
-                        dsoname = al.map->dso->name;
-                else
-                        dsoname = "";
+                        printf(" %s", symname);
+                }
 
-                printf("%16" PRIx64 " %s (%s)", al.addr, symname, dsoname);
+                if (print_dso) {
+                        if (al.map && al.map->dso && al.map->dso->name)
+                                dsoname = al.map->dso->name;
+                        else
+                                dsoname = "";
+
+                        printf(" (%s)", dsoname);
+                }
         }
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 66d4e1490879..de4178d7bb7b 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -167,8 +167,9 @@ static inline int perf_session__parse_sample(struct perf_session *session,
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                             unsigned int type);
 
-void perf_session__print_symbols(union perf_event *event,
+void perf_session__print_ip(union perf_event *event,
                                  struct perf_sample *sample,
-                                 struct perf_session *session);
+                                 struct perf_session *session,
+                                 int print_sym, int print_dso);
 
 #endif /* __PERF_SESSION_H */