Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

perf: Simplify and fix __perf_install_in_context()

Browse source 
Currently __perf_install_in_context() will try and schedule in the
event irrespective of our event scheduling rules, that is, we try to
schedule CPU-pinned, TASK-pinned, CPU-flexible, TASK-flexible, but
when creating a new event we simply try and schedule it on top of
whatever is already on the PMU, this can lead to errors for pinned
events.

Therefore, simplify things and simply schedule everything out, add the
event to the corresponding context and schedule everything back in.

This also nicely handles the case where with
__ARCH_WANT_INTERRUPTS_ON_CTXSW the IPI can come right in the middle
of schedule, before we managed to call perf_event_task_sched_in().

Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20110409192141.870894224@chello.nl
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Peter Zijlstra 2011-04-09 21:17:44 +02:00 committed by Ingo Molnar
parent 04dc2dbbfe
commit 2c29ef0fef
1 changed files with 35 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

80
kernel/events/core.c
View file

@ -1469,8 +1469,12 @@ 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);
/*
* Cross CPU call to install and enable a performance event
@ -1481,20 +1485,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
@ -1505,43 +1520,18 @@ 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.
* Schedule everything back in
*/
if (event->state != PERF_EVENT_STATE_INACTIVE ||
(leader != event && leader->state != PERF_EVENT_STATE_ACTIVE))
goto unlock;
cpu_ctx_sched_in(cpuctx, EVENT_PINNED, task);
if (task_ctx)
ctx_sched_in(task_ctx, cpuctx, EVENT_PINNED, task);
cpu_ctx_sched_in(cpuctx, EVENT_FLEXIBLE, task);
if (task_ctx)
ctx_sched_in(task_ctx, cpuctx, EVENT_FLEXIBLE, task);
/*
* 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.
*/
if (!group_can_go_on(event, cpuctx, 1))
err = -EEXIST;
else
err = event_sched_in(event, cpuctx, ctx);
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;
}