1 files changed, 103 insertions, 99 deletions

diff --git a/kernel/perf_event.c b/kernel/perf_event.c
index 6b7ddba1dd64..97d1a3dd7a59 100644
--- a/kernel/perf_event.c
+++ b/kernel/perf_event.c
@@ -36,7 +36,7 @@
 /*
  * Each CPU has a list of per CPU events:
  */
-DEFINE_PER_CPU(struct perf_cpu_context, perf_cpu_context);
+static DEFINE_PER_CPU(struct perf_cpu_context, perf_cpu_context);
 
 int perf_max_events __read_mostly = 1;
 static int perf_reserved_percpu __read_mostly;
@@ -203,14 +203,14 @@ perf_lock_task_context(struct task_struct *task, unsigned long *flags)
                  * if so.  If we locked the right context, then it
                  * can't get swapped on us any more.
                  */
-                spin_lock_irqsave(&ctx->lock, *flags);
+                raw_spin_lock_irqsave(&ctx->lock, *flags);
                 if (ctx != rcu_dereference(task->perf_event_ctxp)) {
-                        spin_unlock_irqrestore(&ctx->lock, *flags);
+                        raw_spin_unlock_irqrestore(&ctx->lock, *flags);
                         goto retry;
                 }
 
                 if (!atomic_inc_not_zero(&ctx->refcount)) {
-                        spin_unlock_irqrestore(&ctx->lock, *flags);
+                        raw_spin_unlock_irqrestore(&ctx->lock, *flags);
                         ctx = NULL;
                 }
         }
@@ -231,7 +231,7 @@ static struct perf_event_context *perf_pin_task_context(struct task_struct *task
         ctx = perf_lock_task_context(task, &flags);
         if (ctx) {
                 ++ctx->pin_count;
-                spin_unlock_irqrestore(&ctx->lock, flags);
+                raw_spin_unlock_irqrestore(&ctx->lock, flags);
         }
         return ctx;
 }
@@ -240,9 +240,9 @@ static void perf_unpin_context(struct perf_event_context *ctx)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&ctx->lock, flags);
+        raw_spin_lock_irqsave(&ctx->lock, flags);
         --ctx->pin_count;
-        spin_unlock_irqrestore(&ctx->lock, flags);
+        raw_spin_unlock_irqrestore(&ctx->lock, flags);
         put_ctx(ctx);
 }
 
@@ -427,7 +427,7 @@ static void __perf_event_remove_from_context(void *info)
         if (ctx->task && cpuctx->task_ctx != ctx)
                 return;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         /*
          * Protect the list operation against NMI by disabling the
          * events on a global level.
@@ -449,7 +449,7 @@ static void __perf_event_remove_from_context(void *info)
         }
 
         perf_enable();
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 
@@ -476,7 +476,7 @@ static void perf_event_remove_from_context(struct perf_event *event)
         if (!task) {
                 /*
                  * Per cpu events are removed via an smp call and
-                 * the removal is always sucessful.
+                 * the removal is always successful.
                  */
                 smp_call_function_single(event->cpu,
                                          __perf_event_remove_from_context,
@@ -488,12 +488,12 @@ retry:
         task_oncpu_function_call(task, __perf_event_remove_from_context,
                                  event);
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
         /*
          * If the context is active we need to retry the smp call.
          */
         if (ctx->nr_active && !list_empty(&event->group_entry)) {
-                spin_unlock_irq(&ctx->lock);
+                raw_spin_unlock_irq(&ctx->lock);
                 goto retry;
         }
 
@@ -504,7 +504,7 @@ retry:
          */
         if (!list_empty(&event->group_entry))
                 list_del_event(event, ctx);
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
 }
 
 /*
@@ -535,7 +535,7 @@ static void __perf_event_disable(void *info)
         if (ctx->task && cpuctx->task_ctx != ctx)
                 return;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
 
         /*
          * If the event is on, turn it off.
@@ -551,7 +551,7 @@ static void __perf_event_disable(void *info)
                 event->state = PERF_EVENT_STATE_OFF;
         }
 
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -567,7 +567,7 @@ static void __perf_event_disable(void *info)
  * is the current context on this CPU and preemption is disabled,
  * hence we can't get into perf_event_task_sched_out for this context.
  */
-static void perf_event_disable(struct perf_event *event)
+void perf_event_disable(struct perf_event *event)
 {
         struct perf_event_context *ctx = event->ctx;
         struct task_struct *task = ctx->task;
@@ -584,12 +584,12 @@ static void perf_event_disable(struct perf_event *event)
  retry:
         task_oncpu_function_call(task, __perf_event_disable, event);
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
         /*
          * If the event is still active, we need to retry the cross-call.
          */
         if (event->state == PERF_EVENT_STATE_ACTIVE) {
-                spin_unlock_irq(&ctx->lock);
+                raw_spin_unlock_irq(&ctx->lock);
                 goto retry;
         }
 
@@ -602,7 +602,7 @@ static void perf_event_disable(struct perf_event *event)
                 event->state = PERF_EVENT_STATE_OFF;
         }
 
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
 }
 
 static int
@@ -770,7 +770,7 @@ static void __perf_install_in_context(void *info)
                 cpuctx->task_ctx = ctx;
         }
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         ctx->is_active = 1;
         update_context_time(ctx);
 
@@ -782,6 +782,9 @@ static void __perf_install_in_context(void *info)
 
         add_event_to_ctx(event, ctx);
 
+        if (event->cpu != -1 && event->cpu != smp_processor_id())
+                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.
@@ -820,7 +823,7 @@ static void __perf_install_in_context(void *info)
  unlock:
         perf_enable();
 
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -845,7 +848,7 @@ perf_install_in_context(struct perf_event_context *ctx,
         if (!task) {
                 /*
                  * Per cpu events are installed via an smp call and
-                 * the install is always sucessful.
+                 * the install is always successful.
                  */
                 smp_call_function_single(cpu, __perf_install_in_context,
                                          event, 1);
@@ -856,12 +859,12 @@ retry:
         task_oncpu_function_call(task, __perf_install_in_context,
                                  event);
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
         /*
          * we need to retry the smp call.
          */
         if (ctx->is_active && list_empty(&event->group_entry)) {
-                spin_unlock_irq(&ctx->lock);
+                raw_spin_unlock_irq(&ctx->lock);
                 goto retry;
         }
 
@@ -872,7 +875,7 @@ retry:
          */
         if (list_empty(&event->group_entry))
                 add_event_to_ctx(event, ctx);
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
 }
 
 /*
@@ -917,7 +920,7 @@ static void __perf_event_enable(void *info)
                 cpuctx->task_ctx = ctx;
         }
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         ctx->is_active = 1;
         update_context_time(ctx);
 
@@ -925,6 +928,9 @@ static void __perf_event_enable(void *info)
                 goto unlock;
         __perf_event_mark_enabled(event, ctx);
 
+        if (event->cpu != -1 && event->cpu != smp_processor_id())
+                goto unlock;
+
         /*
          * If the event is in a group and isn't the group leader,
          * then don't put it on unless the group is on.
@@ -959,7 +965,7 @@ static void __perf_event_enable(void *info)
         }
 
  unlock:
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -971,7 +977,7 @@ static void __perf_event_enable(void *info)
  * perf_event_for_each_child or perf_event_for_each as described
  * for perf_event_disable.
  */
-static void perf_event_enable(struct perf_event *event)
+void perf_event_enable(struct perf_event *event)
 {
         struct perf_event_context *ctx = event->ctx;
         struct task_struct *task = ctx->task;
@@ -985,7 +991,7 @@ static void perf_event_enable(struct perf_event *event)
                 return;
         }
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
         if (event->state >= PERF_EVENT_STATE_INACTIVE)
                 goto out;
 
@@ -1000,10 +1006,10 @@ static void perf_event_enable(struct perf_event *event)
                 event->state = PERF_EVENT_STATE_OFF;
 
  retry:
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
         task_oncpu_function_call(task, __perf_event_enable, event);
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
 
         /*
          * If the context is active and the event is still off,
@@ -1020,7 +1026,7 @@ static void perf_event_enable(struct perf_event *event)
                 __perf_event_mark_enabled(event, ctx);
 
  out:
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
 }
 
 static int perf_event_refresh(struct perf_event *event, int refresh)
@@ -1042,7 +1048,7 @@ void __perf_event_sched_out(struct perf_event_context *ctx,
 {
         struct perf_event *event;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         ctx->is_active = 0;
         if (likely(!ctx->nr_events))
                 goto out;
@@ -1055,7 +1061,7 @@ void __perf_event_sched_out(struct perf_event_context *ctx,
         }
         perf_enable();
  out:
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -1193,8 +1199,8 @@ void perf_event_task_sched_out(struct task_struct *task,
                  * order we take the locks because no other cpu could
                  * be trying to lock both of these tasks.
                  */
-                spin_lock(&ctx->lock);
-                spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
+                raw_spin_lock(&ctx->lock);
+                raw_spin_lock_nested(&next_ctx->lock, SINGLE_DEPTH_NESTING);
                 if (context_equiv(ctx, next_ctx)) {
                         /*
                          * XXX do we need a memory barrier of sorts
@@ -1208,8 +1214,8 @@ void perf_event_task_sched_out(struct task_struct *task,
 
                         perf_event_sync_stat(ctx, next_ctx);
                 }
-                spin_unlock(&next_ctx->lock);
-                spin_unlock(&ctx->lock);
+                raw_spin_unlock(&next_ctx->lock);
+                raw_spin_unlock(&ctx->lock);
         }
         rcu_read_unlock();
 
@@ -1251,7 +1257,7 @@ __perf_event_sched_in(struct perf_event_context *ctx,
         struct perf_event *event;
         int can_add_hw = 1;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         ctx->is_active = 1;
         if (likely(!ctx->nr_events))
                 goto out;
@@ -1306,7 +1312,7 @@ __perf_event_sched_in(struct perf_event_context *ctx,
         }
         perf_enable();
  out:
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -1370,7 +1376,7 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx)
         struct hw_perf_event *hwc;
         u64 interrupts, freq;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         list_for_each_entry_rcu(event, &ctx->event_list, event_entry) {
                 if (event->state != PERF_EVENT_STATE_ACTIVE)
                         continue;
@@ -1425,7 +1431,7 @@ static void perf_ctx_adjust_freq(struct perf_event_context *ctx)
                         perf_enable();
                 }
         }
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 /*
@@ -1438,7 +1444,7 @@ static void rotate_ctx(struct perf_event_context *ctx)
         if (!ctx->nr_events)
                 return;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         /*
          * Rotate the first entry last (works just fine for group events too):
          */
@@ -1449,7 +1455,7 @@ static void rotate_ctx(struct perf_event_context *ctx)
         }
         perf_enable();
 
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 }
 
 void perf_event_task_tick(struct task_struct *curr, int cpu)
@@ -1498,7 +1504,7 @@ static void perf_event_enable_on_exec(struct task_struct *task)
 
         __perf_event_task_sched_out(ctx);
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
 
         list_for_each_entry(event, &ctx->group_list, group_entry) {
                 if (!event->attr.enable_on_exec)
@@ -1516,7 +1522,7 @@ static void perf_event_enable_on_exec(struct task_struct *task)
         if (enabled)
                 unclone_ctx(ctx);
 
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 
         perf_event_task_sched_in(task, smp_processor_id());
  out:
@@ -1542,10 +1548,10 @@ static void __perf_event_read(void *info)
         if (ctx->task && cpuctx->task_ctx != ctx)
                 return;
 
-        spin_lock(&ctx->lock);
+        raw_spin_lock(&ctx->lock);
         update_context_time(ctx);
         update_event_times(event);
-        spin_unlock(&ctx->lock);
+        raw_spin_unlock(&ctx->lock);
 
         event->pmu->read(event);
 }
@@ -1563,10 +1569,10 @@ static u64 perf_event_read(struct perf_event *event)
                 struct perf_event_context *ctx = event->ctx;
                 unsigned long flags;
 
-                spin_lock_irqsave(&ctx->lock, flags);
+                raw_spin_lock_irqsave(&ctx->lock, flags);
                 update_context_time(ctx);
                 update_event_times(event);
-                spin_unlock_irqrestore(&ctx->lock, flags);
+                raw_spin_unlock_irqrestore(&ctx->lock, flags);
         }
 
         return atomic64_read(&event->count);
@@ -1579,8 +1585,7 @@ static void
 __perf_event_init_context(struct perf_event_context *ctx,
                             struct task_struct *task)
 {
-        memset(ctx, 0, sizeof(*ctx));
-        spin_lock_init(&ctx->lock);
+        raw_spin_lock_init(&ctx->lock);
         mutex_init(&ctx->mutex);
         INIT_LIST_HEAD(&ctx->group_list);
         INIT_LIST_HEAD(&ctx->event_list);
@@ -1596,15 +1601,12 @@ static struct perf_event_context *find_get_context(pid_t pid, int cpu)
         unsigned long flags;
         int err;
 
-        /*
-         * If cpu is not a wildcard then this is a percpu event:
-         */
-        if (cpu != -1) {
+        if (pid == -1 && cpu != -1) {
                 /* Must be root to operate on a CPU event: */
                 if (perf_paranoid_cpu() && !capable(CAP_SYS_ADMIN))
                         return ERR_PTR(-EACCES);
 
-                if (cpu < 0 || cpu > num_possible_cpus())
+                if (cpu < 0 || cpu >= nr_cpumask_bits)
                         return ERR_PTR(-EINVAL);
 
                 /*
@@ -1612,7 +1614,7 @@ static struct perf_event_context *find_get_context(pid_t pid, int cpu)
                  * offline CPU and activate it when the CPU comes up, but
                  * that's for later.
                  */
-                if (!cpu_isset(cpu, cpu_online_map))
+                if (!cpu_online(cpu))
                         return ERR_PTR(-ENODEV);
 
                 cpuctx = &per_cpu(perf_cpu_context, cpu);
@@ -1650,11 +1652,11 @@ static struct perf_event_context *find_get_context(pid_t pid, int cpu)
         ctx = perf_lock_task_context(task, &flags);
         if (ctx) {
                 unclone_ctx(ctx);
-                spin_unlock_irqrestore(&ctx->lock, flags);
+                raw_spin_unlock_irqrestore(&ctx->lock, flags);
         }
 
         if (!ctx) {
-                ctx = kmalloc(sizeof(struct perf_event_context), GFP_KERNEL);
+                ctx = kzalloc(sizeof(struct perf_event_context), GFP_KERNEL);
                 err = -ENOMEM;
                 if (!ctx)
                         goto errout;
@@ -1988,7 +1990,7 @@ static int perf_event_period(struct perf_event *event, u64 __user *arg)
         if (!value)
                 return -EINVAL;
 
-        spin_lock_irq(&ctx->lock);
+        raw_spin_lock_irq(&ctx->lock);
         if (event->attr.freq) {
                 if (value > sysctl_perf_event_sample_rate) {
                         ret = -EINVAL;
@@ -2001,7 +2003,7 @@ static int perf_event_period(struct perf_event *event, u64 __user *arg)
                 event->hw.sample_period = value;
         }
 unlock:
-        spin_unlock_irq(&ctx->lock);
+        raw_spin_unlock_irq(&ctx->lock);
 
         return ret;
 }
@@ -4011,6 +4013,7 @@ static enum hrtimer_restart perf_swevent_hrtimer(struct hrtimer *hrtimer)
         event->pmu->read(event);
 
         data.addr = 0;
+        data.raw = NULL;
         data.period = event->hw.last_period;
         regs = get_irq_regs();
         /*
@@ -4080,8 +4083,7 @@ static void cpu_clock_perf_event_update(struct perf_event *event)
         u64 now;
 
         now = cpu_clock(cpu);
-        prev = atomic64_read(&event->hw.prev_count);
-        atomic64_set(&event->hw.prev_count, now);
+        prev = atomic64_xchg(&event->hw.prev_count, now);
         atomic64_add(now - prev, &event->count);
 }
 
@@ -4286,15 +4288,8 @@ static void bp_perf_event_destroy(struct perf_event *event)
 static const struct pmu *bp_perf_event_init(struct perf_event *bp)
 {
         int err;
-        /*
-         * The breakpoint is already filled if we haven't created the counter
-         * through perf syscall
-         * FIXME: manage to get trigerred to NULL if it comes from syscalls
-         */
-        if (!bp->callback)
-                err = register_perf_hw_breakpoint(bp);
-        else
-                err = __register_perf_hw_breakpoint(bp);
+
+        err = register_perf_hw_breakpoint(bp);
         if (err)
                 return ERR_PTR(err);
 
@@ -4308,6 +4303,7 @@ void perf_bp_event(struct perf_event *bp, void *data)
         struct perf_sample_data sample;
         struct pt_regs *regs = data;
 
+        sample.raw = NULL;
         sample.addr = bp->attr.bp_addr;
 
         if (!perf_exclude_event(bp, regs))
@@ -4390,7 +4386,7 @@ perf_event_alloc(struct perf_event_attr *attr,
                    struct perf_event_context *ctx,
                    struct perf_event *group_leader,
                    struct perf_event *parent_event,
-                   perf_callback_t callback,
+                   perf_overflow_handler_t overflow_handler,
                    gfp_t gfpflags)
 {
         const struct pmu *pmu;
@@ -4433,10 +4429,10 @@ perf_event_alloc(struct perf_event_attr *attr,
 
         event->state            = PERF_EVENT_STATE_INACTIVE;
 
-        if (!callback && parent_event)
-                callback = parent_event->callback;
+        if (!overflow_handler && parent_event)
+                overflow_handler = parent_event->overflow_handler;
         
-        event->callback = callback;
+        event->overflow_handler = overflow_handler;
 
         if (attr->disabled)
                 event->state = PERF_EVENT_STATE_OFF;
@@ -4571,7 +4567,7 @@ static int perf_copy_attr(struct perf_event_attr __user *uattr,
         if (attr->type >= PERF_TYPE_MAX)
                 return -EINVAL;
 
-        if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3)
+        if (attr->__reserved_1 || attr->__reserved_2)
                 return -EINVAL;
 
         if (attr->sample_type & ~(PERF_SAMPLE_MAX-1))
@@ -4776,7 +4772,8 @@ err_put_context:
  */
 struct perf_event *
 perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
-                                 pid_t pid, perf_callback_t callback)
+                                 pid_t pid,
+                                 perf_overflow_handler_t overflow_handler)
 {
         struct perf_event *event;
         struct perf_event_context *ctx;
@@ -4793,7 +4790,7 @@ perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu,
         }
 
         event = perf_event_alloc(attr, cpu, ctx, NULL,
-                                     NULL, callback, GFP_KERNEL);
+                                 NULL, overflow_handler, GFP_KERNEL);
         if (IS_ERR(event)) {
                 err = PTR_ERR(event);
                 goto err_put_context;
@@ -4998,7 +4995,7 @@ void perf_event_exit_task(struct task_struct *child)
          * reading child->perf_event_ctxp, we wait until it has
          * incremented the context's refcount before we do put_ctx below.
          */
-        spin_lock(&child_ctx->lock);
+        raw_spin_lock(&child_ctx->lock);
         child->perf_event_ctxp = NULL;
         /*
          * If this context is a clone; unclone it so it can't get
@@ -5007,7 +5004,7 @@ void perf_event_exit_task(struct task_struct *child)
          */
         unclone_ctx(child_ctx);
         update_context_time(child_ctx);
-        spin_unlock_irqrestore(&child_ctx->lock, flags);
+        raw_spin_unlock_irqrestore(&child_ctx->lock, flags);
 
         /*
          * Report the task dead after unscheduling the events so that we
@@ -5090,7 +5087,7 @@ again:
  */
 int perf_event_init_task(struct task_struct *child)
 {
-        struct perf_event_context *child_ctx, *parent_ctx;
+        struct perf_event_context *child_ctx = NULL, *parent_ctx;
         struct perf_event_context *cloned_ctx;
         struct perf_event *event;
         struct task_struct *parent = current;
@@ -5106,20 +5103,6 @@ int perf_event_init_task(struct task_struct *child)
                 return 0;
 
         /*
-         * This is executed from the parent task context, so inherit
-         * events that have been marked for cloning.
-         * First allocate and initialize a context for the child.
-         */
-
-        child_ctx = kmalloc(sizeof(struct perf_event_context), GFP_KERNEL);
-        if (!child_ctx)
-                return -ENOMEM;
-
-        __perf_event_init_context(child_ctx, child);
-        child->perf_event_ctxp = child_ctx;
-        get_task_struct(child);
-
-        /*
          * If the parent's context is a clone, pin it so it won't get
          * swapped under us.
          */
@@ -5149,6 +5132,26 @@ int perf_event_init_task(struct task_struct *child)
                         continue;
                 }
 
+                if (!child->perf_event_ctxp) {
+                        /*
+                         * This is executed from the parent task context, so
+                         * inherit events that have been marked for cloning.
+                         * First allocate and initialize a context for the
+                         * child.
+                         */
+
+                        child_ctx = kzalloc(sizeof(struct perf_event_context),
+                                            GFP_KERNEL);
+                        if (!child_ctx) {
+                                ret = -ENOMEM;
+                                goto exit;
+                        }
+
+                        __perf_event_init_context(child_ctx, child);
+                        child->perf_event_ctxp = child_ctx;
+                        get_task_struct(child);
+                }
+
                 ret = inherit_group(event, parent, parent_ctx,
                                              child, child_ctx);
                 if (ret) {
@@ -5177,6 +5180,7 @@ int perf_event_init_task(struct task_struct *child)
                 get_ctx(child_ctx->parent_ctx);
         }
 
+exit:
         mutex_unlock(&parent_ctx->mutex);
 
         perf_unpin_context(parent_ctx);
@@ -5291,11 +5295,11 @@ perf_set_reserve_percpu(struct sysdev_class *class,
         perf_reserved_percpu = val;
         for_each_online_cpu(cpu) {
                 cpuctx = &per_cpu(perf_cpu_context, cpu);
-                spin_lock_irq(&cpuctx->ctx.lock);
+                raw_spin_lock_irq(&cpuctx->ctx.lock);
                 mpt = min(perf_max_events - cpuctx->ctx.nr_events,
                           perf_max_events - perf_reserved_percpu);
                 cpuctx->max_pertask = mpt;
-                spin_unlock_irq(&cpuctx->ctx.lock);
+                raw_spin_unlock_irq(&cpuctx->ctx.lock);
         }
         spin_unlock(&perf_resource_lock);