1 files changed, 53 insertions, 16 deletions

diff --git a/arch/x86/kernel/cpu/perf_event.c b/arch/x86/kernel/cpu/perf_event.c
index 1025f3c99d20..9e581c5cf6d0 100644
--- a/arch/x86/kernel/cpu/perf_event.c
+++ b/arch/x86/kernel/cpu/perf_event.c
@@ -403,7 +403,8 @@ int x86_pmu_hw_config(struct perf_event *event)
                  * check that PEBS LBR correction does not conflict with
                  * whatever the user is asking with attr->branch_sample_type
                  */
-                if (event->attr.precise_ip > 1) {
+                if (event->attr.precise_ip > 1 &&
+                    x86_pmu.intel_cap.pebs_format < 2) {
                         u64 *br_type = &event->attr.branch_sample_type;
 
                         if (has_branch_stack(event)) {
@@ -568,7 +569,7 @@ struct sched_state {
 struct perf_sched {
         int                     max_weight;
         int                     max_events;
-        struct event_constraint **constraints;
+        struct perf_event       **events;
         struct sched_state      state;
         int                     saved_states;
         struct sched_state      saved[SCHED_STATES_MAX];
@@ -577,7 +578,7 @@ struct perf_sched {
 /*
  * Initialize interator that runs through all events and counters.
  */
-static void perf_sched_init(struct perf_sched *sched, struct event_constraint **c,
+static void perf_sched_init(struct perf_sched *sched, struct perf_event **events,
                             int num, int wmin, int wmax)
 {
         int idx;
@@ -585,10 +586,10 @@ static void perf_sched_init(struct perf_sched *sched, struct event_constraint **
         memset(sched, 0, sizeof(*sched));
         sched->max_events       = num;
         sched->max_weight       = wmax;
-        sched->constraints      = c;
+        sched->events           = events;
 
         for (idx = 0; idx < num; idx++) {
-                if (c[idx]->weight == wmin)
+                if (events[idx]->hw.constraint->weight == wmin)
                         break;
         }
 
@@ -635,8 +636,7 @@ static bool __perf_sched_find_counter(struct perf_sched *sched)
         if (sched->state.event >= sched->max_events)
                 return false;
 
-        c = sched->constraints[sched->state.event];
-
+        c = sched->events[sched->state.event]->hw.constraint;
         /* Prefer fixed purpose counters */
         if (c->idxmsk64 & (~0ULL << INTEL_PMC_IDX_FIXED)) {
                 idx = INTEL_PMC_IDX_FIXED;
@@ -694,7 +694,7 @@ static bool perf_sched_next_event(struct perf_sched *sched)
                         if (sched->state.weight > sched->max_weight)
                                 return false;
                 }
-                c = sched->constraints[sched->state.event];
+                c = sched->events[sched->state.event]->hw.constraint;
         } while (c->weight != sched->state.weight);
 
         sched->state.counter = 0;       /* start with first counter */
@@ -705,12 +705,12 @@ static bool perf_sched_next_event(struct perf_sched *sched)
 /*
  * Assign a counter for each event.
  */
-int perf_assign_events(struct event_constraint **constraints, int n,
+int perf_assign_events(struct perf_event **events, int n,
                         int wmin, int wmax, int *assign)
 {
         struct perf_sched sched;
 
-        perf_sched_init(&sched, constraints, n, wmin, wmax);
+        perf_sched_init(&sched, events, n, wmin, wmax);
 
         do {
                 if (!perf_sched_find_counter(&sched))
@@ -724,16 +724,19 @@ int perf_assign_events(struct event_constraint **constraints, int n,
 
 int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign)
 {
-        struct event_constraint *c, *constraints[X86_PMC_IDX_MAX];
+        struct event_constraint *c;
         unsigned long used_mask[BITS_TO_LONGS(X86_PMC_IDX_MAX)];
+        struct perf_event *e;
         int i, wmin, wmax, num = 0;
         struct hw_perf_event *hwc;
 
         bitmap_zero(used_mask, X86_PMC_IDX_MAX);
 
         for (i = 0, wmin = X86_PMC_IDX_MAX, wmax = 0; i < n; i++) {
+                hwc = &cpuc->event_list[i]->hw;
                 c = x86_pmu.get_event_constraints(cpuc, cpuc->event_list[i]);
-                constraints[i] = c;
+                hwc->constraint = c;
+
                 wmin = min(wmin, c->weight);
                 wmax = max(wmax, c->weight);
         }
@@ -743,7 +746,7 @@ int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign)
          */
         for (i = 0; i < n; i++) {
                 hwc = &cpuc->event_list[i]->hw;
-                c = constraints[i];
+                c = hwc->constraint;
 
                 /* never assigned */
                 if (hwc->idx == -1)
@@ -764,16 +767,35 @@ int x86_schedule_events(struct cpu_hw_events *cpuc, int n, int *assign)
 
         /* slow path */
         if (i != n)
-                num = perf_assign_events(constraints, n, wmin, wmax, assign);
+                num = perf_assign_events(cpuc->event_list, n, wmin,
+                                         wmax, assign);
 
         /*
+         * Mark the event as committed, so we do not put_constraint()
+         * in case new events are added and fail scheduling.
+         */
+        if (!num && assign) {
+                for (i = 0; i < n; i++) {
+                        e = cpuc->event_list[i];
+                        e->hw.flags |= PERF_X86_EVENT_COMMITTED;
+                }
+        }
+        /*
          * scheduling failed or is just a simulation,
          * free resources if necessary
          */
         if (!assign || num) {
                 for (i = 0; i < n; i++) {
+                        e = cpuc->event_list[i];
+                        /*
+                         * do not put_constraint() on comitted events,
+                         * because they are good to go
+                         */
+                        if ((e->hw.flags & PERF_X86_EVENT_COMMITTED))
+                                continue;
+
                         if (x86_pmu.put_event_constraints)
-                                x86_pmu.put_event_constraints(cpuc, cpuc->event_list[i]);
+                                x86_pmu.put_event_constraints(cpuc, e);
                 }
         }
         return num ? -EINVAL : 0;
@@ -1153,6 +1175,11 @@ static void x86_pmu_del(struct perf_event *event, int flags)
         int i;
 
         /*
+         * event is descheduled
+         */
+        event->hw.flags &= ~PERF_X86_EVENT_COMMITTED;
+
+        /*
          * If we're called during a txn, we don't need to do anything.
          * The events never got scheduled and ->cancel_txn will truncate
          * the event_list.
@@ -1249,10 +1276,20 @@ void perf_events_lapic_init(void)
 static int __kprobes
 perf_event_nmi_handler(unsigned int cmd, struct pt_regs *regs)
 {
+        int ret;
+        u64 start_clock;
+        u64 finish_clock;
+
         if (!atomic_read(&active_events))
                 return NMI_DONE;
 
-        return x86_pmu.handle_irq(regs);
+        start_clock = local_clock();
+        ret = x86_pmu.handle_irq(regs);
+        finish_clock = local_clock();
+
+        perf_sample_event_took(finish_clock - start_clock);
+
+        return ret;
 }
 
 struct event_constraint emptyconstraint;