More perf patches
Subsystems (3)
cover More perf patches
PATCH 1/8 perf: undo copy/paste damage
We had two almost identical functions, avoid the duplication.
--- kernel/perf_event.c | 31 +++++++++---------------------- 1 file changed, 9 insertions(+), 22 deletions(-)
kernel/perf_event.c +9 -22
@@ -1704,16 +1704,10 @@ static void free_event(struct perf_eventcall_rcu (&event->rcu_head, free_event_rcu); } -/* -* Called when the last reference to the file is gone. -*/ -static int perf_release (struct inode *inode,struct file *file) +int perf_event_release_kernel (struct perf_event *event) { -struct perf_event *event = file->private_data;struct perf_event_context *ctx = event->ctx; - file->private_data =NULL ; -WARN_ON_ONCE (ctx->parent_ctx);mutex_lock (&ctx->mutex);perf_event_remove_from_context (event);
@@ -1728,26 +1722,19 @@ static int perf_release(struct inode *inreturn 0 ; } +EXPORT_SYMBOL_GPL (perf_event_release_kernel); -int perf_event_release_kernel (struct perf_event *event) +/* +* Called when the last reference to the file is gone. +*/ +static int perf_release (struct inode *inode,struct file *file) { -struct perf_event_context *ctx = event->ctx; - -WARN_ON_ONCE (ctx->parent_ctx); -mutex_lock (&ctx->mutex); -perf_event_remove_from_context (event); -mutex_unlock (&ctx->mutex); - -mutex_lock (&event->owner->perf_event_mutex); -list_del_init (&event->owner_entry); -mutex_unlock (&event->owner->perf_event_mutex); -put_task_struct (event->owner); +struct perf_event *event = file->private_data; -free_event (event); + file->private_data =NULL ; -return 0 ; +return perf_event_release_kernel (event); } -EXPORT_SYMBOL_GPL (perf_event_release_kernel);static int perf_event_read_size (struct perf_event *event) {
[tip:perf/core] perf_events: Undo copy/paste damage
Commit-ID: a66a3052e2d4c5815d7ad26887b1d4193206e691 Gitweb: http://git.kernel.org/tip/a66a3052e2d4c5815d7ad26887b1d4193206e691 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:23 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:55 +0100
perf_events: Undo copy/paste damage
We had two almost identical functions, avoid the duplication.
LKML-Reference: <[email protected]>
--- kernel/perf_event.c | 31 +++++++++---------------------- 1 files changed, 9 insertions(+), 22 deletions(-)
kernel/perf_event.c +9 -22
@@ -1704,16 +1704,10 @@ static void free_event(struct perf_event *event)call_rcu (&event->rcu_head, free_event_rcu); } -/* -* Called when the last reference to the file is gone. -*/ -static int perf_release (struct inode *inode,struct file *file) +int perf_event_release_kernel (struct perf_event *event) { -struct perf_event *event = file->private_data;struct perf_event_context *ctx = event->ctx; - file->private_data =NULL ; -WARN_ON_ONCE (ctx->parent_ctx);mutex_lock (&ctx->mutex);perf_event_remove_from_context (event);
@@ -1728,26 +1722,19 @@ static int perf_release(struct inode *inode, struct file *file)return 0 ; } +EXPORT_SYMBOL_GPL (perf_event_release_kernel); -int perf_event_release_kernel (struct perf_event *event) +/* +* Called when the last reference to the file is gone. +*/ +static int perf_release (struct inode *inode,struct file *file) { -struct perf_event_context *ctx = event->ctx; - -WARN_ON_ONCE (ctx->parent_ctx); -mutex_lock (&ctx->mutex); -perf_event_remove_from_context (event); -mutex_unlock (&ctx->mutex); - -mutex_lock (&event->owner->perf_event_mutex); -list_del_init (&event->owner_entry); -mutex_unlock (&event->owner->perf_event_mutex); -put_task_struct (event->owner); +struct perf_event *event = file->private_data; -free_event (event); + file->private_data =NULL ; -return 0 ; +return perf_event_release_kernel (event); } -EXPORT_SYMBOL_GPL (perf_event_release_kernel);static int perf_event_read_size (struct perf_event *event) {
PATCH 2/8 perf: style nits
In reply to Peter Zijlstra--- kernel/perf_event.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/perf_event.c +3 -4
@@ -449,9 +450,8 @@ retry:* can remove the event safely, if the call above did not * succeed. */ -if (!list_empty (&event->group_entry)) { +if (!list_empty (&event->group_entry))list_del_event (event, ctx); - }spin_unlock_irq (&ctx->lock); }
@@ -1033,10 +1033,10 @@ void __perf_event_sched_out(struct perf_update_context_time (ctx);perf_disable (); -if (ctx->nr_active) +if (ctx->nr_active) {list_for_each_entry (event, &ctx->group_list, group_entry)group_sched_out (event, cpuctx, ctx); - + }perf_enable (); out:spin_unlock (&ctx->lock);
[tip:perf/core] perf_events: Fix style nits
Commit-ID: 6c2bfcbe58e0dd39554be88940149f5aa11e17d1 Gitweb: http://git.kernel.org/tip/6c2bfcbe58e0dd39554be88940149f5aa11e17d1 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:24 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:55 +0100
perf_events: Fix style nits
LKML-Reference: <[email protected]>
--- kernel/perf_event.c | 7 +++---- 1 files changed, 3 insertions(+), 4 deletions(-)
kernel/perf_event.c +3 -4
@@ -447,9 +447,8 @@ retry:* can remove the event safely, if the call above did not * succeed. */ -if (!list_empty (&event->group_entry)) { +if (!list_empty (&event->group_entry))list_del_event (event, ctx); - }spin_unlock_irq (&ctx->lock); }
@@ -1033,10 +1032,10 @@ void __perf_event_sched_out(struct perf_event_context *ctx,update_context_time (ctx);perf_disable (); -if (ctx->nr_active) +if (ctx->nr_active) {list_for_each_entry (event, &ctx->group_list, group_entry)group_sched_out (event, cpuctx, ctx); - + }perf_enable (); out:spin_unlock (&ctx->lock);
PATCH 3/8 perf: disable events when we detach them
In reply to Peter ZijlstraIf we leave the event in STATE_INACTIVE, any read of the event after the detach will increase the running count but not the enabled count and cause funny scaling artefacts.
--- kernel/perf_event.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/perf_event.c +2 -0
@@ -294,6 +294,8 @@ list_del_event(struct perf_event *event,if (event->group_leader != event) event->group_leader->nr_siblings--; + event->state =PERF_EVENT_STATE_OFF ; +/* * If this was a group event with sibling events then * upgrade the siblings to singleton events by adding them
[tip:perf/core] perf_events: Disable events when we detach them
Commit-ID: 2e2af50b1fab3c40636839a7f439c167ae559533 Gitweb: http://git.kernel.org/tip/2e2af50b1fab3c40636839a7f439c167ae559533 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:25 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:56 +0100
perf_events: Disable events when we detach them
If we leave the event in STATE_INACTIVE, any read of the event after the detach will increase the running count but not the enabled count and cause funny scaling artefacts.
LKML-Reference: <[email protected]>
--- kernel/perf_event.c | 2 ++ 1 files changed, 2 insertions(+), 0 deletions(-)
kernel/perf_event.c +2 -0
@@ -294,6 +294,8 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx)if (event->group_leader != event) event->group_leader->nr_siblings--; + event->state =PERF_EVENT_STATE_OFF ; +/* * If this was a group event with sibling events then * upgrade the siblings to singleton events by adding them
PATCH 4/8 perf: update the context time on exit
In reply to Peter ZijlstraIt appeared we did call update_event_times() on exit, but we failed to update the context time, which renders the former moot.
XXX: locking is a bit iffy, we call update_event_times under
ctx->mutex instead of ctx->lock, should probably be fixed in
some way.--- kernel/perf_event.c | 1 + 1 file changed, 1 insertion(+)
kernel/perf_event.c +1 -0
@@ -4982,6 +4982,7 @@ void perf_event_exit_task(struct task_st* the events from it. */ unclone_ctx (child_ctx); +update_context_time (child_ctx);spin_unlock_irqrestore (&child_ctx->lock, flags);/*
[tip:perf/core] perf_events: Update the context time on exit
Commit-ID: 5e942bb33371254a474653123cd9e13a4c89ee44 Gitweb: http://git.kernel.org/tip/5e942bb33371254a474653123cd9e13a4c89ee44 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:26 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:56 +0100
perf_events: Update the context time on exit
It appeared we did call update_event_times() on exit, but we failed to update the context time, which renders the former moot.
Locking is a bit iffy, we call update_event_times under ctx->mutex instead of ctx->lock - the next patch fixes this.
LKML-Reference: <[email protected]>
--- kernel/perf_event.c | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)
kernel/perf_event.c +1 -0
@@ -4983,6 +4983,7 @@ void perf_event_exit_task(struct task_struct *child)* the events from it. */ unclone_ctx (child_ctx); +update_context_time (child_ctx);spin_unlock_irqrestore (&child_ctx->lock, flags);/*
PATCH 5/8 perf: fix __perf_event_exit_task update_event_times locking
In reply to Peter ZijlstraMove the update_event_times() call in __perf_event_exit_task() into list_del_event() because that holds the proper lock (ctx->lock) and seems a more natural place to do the last time update.
--- kernel/perf_event.c | 78 ++++++++++++++++++++++++++-------------------------- 1 file changed, 39 insertions(+), 39 deletions(-)
kernel/perf_event.c +39 -39
@@ -246,6 +246,44 @@ static void perf_unpin_context(struct peput_ctx (ctx); } +static inline u64 perf_clock (void ) +{ +return cpu_clock (smp_processor_id ()); +} + +/* +* Update the record of the current time in a context. +*/ +static void update_context_time (struct perf_event_context *ctx) +{ +u64 now =perf_clock (); + + ctx->time += now - ctx->timestamp; + ctx->timestamp = now; +} + +/* +* Update the total_time_enabled and total_time_running fields for a event. +*/ +static void update_event_times (struct perf_event *event) +{ +struct perf_event_context *ctx = event->ctx; +u64 run_end; + +if (event->state <PERF_EVENT_STATE_INACTIVE || + event->group_leader->state <PERF_EVENT_STATE_INACTIVE ) +return ; + + event->total_time_enabled = ctx->time - event->tstamp_enabled; + +if (event->state ==PERF_EVENT_STATE_INACTIVE ) + run_end = event->tstamp_stopped; +else + run_end = ctx->time; + + event->total_time_running = run_end - event->tstamp_running; +} +/* * Add a event from the lists for its context. * Must be called with ctx->mutex and ctx->lock held.
@@ -294,6 +332,7 @@ list_del_event(struct perf_event *event,if (event->group_leader != event) event->group_leader->nr_siblings--; +update_event_times (event); event->state =PERF_EVENT_STATE_OFF ;/*
@@ -454,44 +493,6 @@ retry:spin_unlock_irq (&ctx->lock); } -static inline u64 perf_clock (void ) -{ -return cpu_clock (smp_processor_id ()); -} - -/* -* Update the record of the current time in a context. -*/ -static void update_context_time (struct perf_event_context *ctx) -{ -u64 now =perf_clock (); - - ctx->time += now - ctx->timestamp; - ctx->timestamp = now; -} - -/* -* Update the total_time_enabled and total_time_running fields for a event. -*/ -static void update_event_times (struct perf_event *event) -{ -struct perf_event_context *ctx = event->ctx; -u64 run_end; - -if (event->state <PERF_EVENT_STATE_INACTIVE || - event->group_leader->state <PERF_EVENT_STATE_INACTIVE ) -return ; - - event->total_time_enabled = ctx->time - event->tstamp_enabled; - -if (event->state ==PERF_EVENT_STATE_INACTIVE ) - run_end = event->tstamp_stopped; -else - run_end = ctx->time; - - event->total_time_running = run_end - event->tstamp_running; -} -/* * Update total_time_enabled and total_time_running for all events in a group. */
@@ -4931,7 +4932,6 @@ __perf_event_exit_task(struct perf_event {struct perf_event *parent_event; -update_event_times (child_event);perf_event_remove_from_context (child_event); parent_event = child_event->parent;
[tip:perf/core] perf_events: Fix __perf_event_exit_task() vs. update_event_times() locking
Commit-ID: f67218c3e93abaf0f480bb94b53d234853ffe4de Gitweb: http://git.kernel.org/tip/f67218c3e93abaf0f480bb94b53d234853ffe4de Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:27 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:57 +0100
perf_events: Fix __perf_event_exit_task() vs. update_event_times() locking
Move the update_event_times() call in __perf_event_exit_task() into list_del_event() because that holds the proper lock (ctx->lock) and seems a more natural place to do the last time update.
LKML-Reference: <[email protected]>
--- kernel/perf_event.c | 78 +++++++++++++++++++++++++------------------------- 1 files changed, 39 insertions(+), 39 deletions(-)
kernel/perf_event.c +39 -39
@@ -246,6 +246,44 @@ static void perf_unpin_context(struct perf_event_context *ctx)put_ctx (ctx); } +static inline u64 perf_clock (void ) +{ +return cpu_clock (smp_processor_id ()); +} + +/* +* Update the record of the current time in a context. +*/ +static void update_context_time (struct perf_event_context *ctx) +{ +u64 now =perf_clock (); + + ctx->time += now - ctx->timestamp; + ctx->timestamp = now; +} + +/* +* Update the total_time_enabled and total_time_running fields for a event. +*/ +static void update_event_times (struct perf_event *event) +{ +struct perf_event_context *ctx = event->ctx; +u64 run_end; + +if (event->state <PERF_EVENT_STATE_INACTIVE || + event->group_leader->state <PERF_EVENT_STATE_INACTIVE ) +return ; + + event->total_time_enabled = ctx->time - event->tstamp_enabled; + +if (event->state ==PERF_EVENT_STATE_INACTIVE ) + run_end = event->tstamp_stopped; +else + run_end = ctx->time; + + event->total_time_running = run_end - event->tstamp_running; +} +/* * Add a event from the lists for its context. * Must be called with ctx->mutex and ctx->lock held.
@@ -294,6 +332,7 @@ list_del_event(struct perf_event *event, struct perf_event_context *ctx)if (event->group_leader != event) event->group_leader->nr_siblings--; +update_event_times (event); event->state =PERF_EVENT_STATE_OFF ;/*
@@ -454,44 +493,6 @@ retry:spin_unlock_irq (&ctx->lock); } -static inline u64 perf_clock (void ) -{ -return cpu_clock (smp_processor_id ()); -} - -/* -* Update the record of the current time in a context. -*/ -static void update_context_time (struct perf_event_context *ctx) -{ -u64 now =perf_clock (); - - ctx->time += now - ctx->timestamp; - ctx->timestamp = now; -} - -/* -* Update the total_time_enabled and total_time_running fields for a event. -*/ -static void update_event_times (struct perf_event *event) -{ -struct perf_event_context *ctx = event->ctx; -u64 run_end; - -if (event->state <PERF_EVENT_STATE_INACTIVE || - event->group_leader->state <PERF_EVENT_STATE_INACTIVE ) -return ; - - event->total_time_enabled = ctx->time - event->tstamp_enabled; - -if (event->state ==PERF_EVENT_STATE_INACTIVE ) - run_end = event->tstamp_stopped; -else - run_end = ctx->time; - - event->total_time_running = run_end - event->tstamp_running; -} -/* * Update total_time_enabled and total_time_running for all events in a group. */
@@ -4931,7 +4932,6 @@ __perf_event_exit_task(struct perf_event *child_event, {struct perf_event *parent_event; -update_event_times (child_event);perf_event_remove_from_context (child_event); parent_event = child_event->parent;
PATCH 6/8 perf: optimize __perf_sw_event()
In reply to Peter ZijlstraFrom: Ingo Molnar <[email protected]>
Ingo noticed that the C99 initialisation of the structure resulted in a memset() and an assignment. Use explicit assignments to avoid the memset.
perf_prepare_sample() initializes all data entries, except:
addr, period and raw.
period is set in perf_swevent_overflow, addr is set here, leaving only raw to be dealt with, so clear that explicitly as well.
--- kernel/perf_event.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
kernel/perf_event.c +4 -3
@@ -3945,9 +3945,10 @@ out:void __perf_sw_event (u32 event_id,u64 nr,int nmi,struct pt_regs *regs,u64 addr) { -struct perf_sample_data data = { - .addr = addr, - }; +struct perf_sample_data data; + + data.addr = addr; + data.raw =NULL ;do_perf_sw_event (PERF_TYPE_SOFTWARE , event_id, nr, nmi, &data, regs);
PATCH 7/8 perf: undo some recursion damage
In reply to Peter ZijlstraMake perf_swevent_get_recursion_context return a context number and disable preemption.
This could be used to remove the IRQ disable from the trace bit and index the per-cpu buffer with.
--- include/linux/perf_event.h | 8 ++-- include/trace/ftrace.h | 17 +++++----- kernel/perf_event.c | 71 ++++++++++++++++++------------------------ kernel/trace/trace_kprobe.c | 14 ++++---- kernel/trace/trace_syscalls.c | 14 ++++---- 5 files changed, 61 insertions(+), 63 deletions(-)
include/linux/perf_event.h +4 -4
@@ -874,8 +874,8 @@ extern int perf_output_begin(struct perfextern void perf_output_end (struct perf_output_handle *handle);extern void perf_output_copy (struct perf_output_handle *handle,const void *buf,unsigned int len); -extern int perf_swevent_get_recursion_context (int **recursion); -extern void perf_swevent_put_recursion_context (int *recursion); +extern int perf_swevent_get_recursion_context (void ); +extern void perf_swevent_put_recursion_context (int rctx);#else static inline void perf_event_task_sched_in (struct task_struct *task,int cpu) { }
@@ -904,8 +904,8 @@ static inline void perf_event_mmap(strucstatic inline void perf_event_comm (struct task_struct *tsk) { }static inline void perf_event_fork (struct task_struct *tsk) { }static inline void perf_event_init (void ) { } -static int perf_swevent_get_recursion_context (int **recursion) {return -1 ; } -static void perf_swevent_put_recursion_context (int *recursion) { } +static inline int perf_swevent_get_recursion_context (void ) {return -1 ; } +static inline void perf_swevent_put_recursion_context (int rctx) { }#endif
include/trace/ftrace.h +9 -8
@@ -724,8 +724,8 @@ __attribute__((section("_ftrace_events") static void ftrace_profile_##call(proto) \ { \ struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\ - extern int perf_swevent_get_recursion_context(int **recursion); \ - extern void perf_swevent_put_recursion_context(int *recursion); \ + extern int perf_swevent_get_recursion_context(void); \ + extern void perf_swevent_put_recursion_context(int rctx); \ struct ftrace_event_call *event_call = &event_##call; \ extern void perf_tp_event(int, u64, u64, void *, int); \ struct ftrace_raw_##call *entry; \
@@ -736,8 +736,8 @@ static void ftrace_profile_##call(proto)int __data_size; \char *trace_buf; \char *raw_data; \ -int *recursion; \int __cpu; \ +int rctx; \int pc; \ \ pc =preempt_count (); \
@@ -753,8 +753,9 @@ static void ftrace_profile_##call(proto) \local_irq_save (irq_flags); \ \ -if (perf_swevent_get_recursion_context (&recursion)) \ - goto end_recursion; \ + rctx =perf_swevent_get_recursion_context (); \ +if (rctx <0 ) \ + goto end_recursion; \ \ __cpu =smp_processor_id (); \ \
@@ -781,9 +782,9 @@ static void ftrace_profile_##call(proto)perf_tp_event (event_call->id, __addr, __count, entry, \ __entry_size); \ \ -end: \ -perf_swevent_put_recursion_context (recursion); \ -end_recursion: \ +end: \ +perf_swevent_put_recursion_context (rctx); \ +end_recursion: \local_irq_restore (irq_flags); \ \ }
kernel/perf_event.c +32 -39
119 lines not on this page · raw message
kernel/trace/trace_kprobe.c +8 -6
@@ -1213,7 +1213,7 @@ static __kprobes int kprobe_profile_funcunsigned long irq_flags;char *trace_buf;char *raw_data; -int *recursion; +int rctx; pc =preempt_count (); __size =SIZEOF_KPROBE_TRACE_ENTRY (tp->nr_args);
@@ -1229,7 +1229,8 @@ static __kprobes int kprobe_profile_func*/ local_irq_save (irq_flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; __cpu =smp_processor_id ();
@@ -1258,7 +1259,7 @@ static __kprobes int kprobe_profile_funcperf_tp_event (call->id, entry->ip,1 , entry, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (irq_flags);
@@ -1276,8 +1277,8 @@ static __kprobes int kretprobe_profile_fint size, __size, i, pc, __cpu;unsigned long irq_flags;char *trace_buf; -int *recursion;char *raw_data; +int rctx; pc =preempt_count (); __size =SIZEOF_KRETPROBE_TRACE_ENTRY (tp->nr_args);
@@ -1293,7 +1294,8 @@ static __kprobes int kretprobe_profile_f*/ local_irq_save (irq_flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; __cpu =smp_processor_id ();
@@ -1323,7 +1325,7 @@ static __kprobes int kretprobe_profile_fperf_tp_event (call->id, entry->ret_ip,1 , entry, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (irq_flags);
kernel/trace/trace_syscalls.c +8 -6
@@ -481,8 +481,8 @@ static void prof_syscall_enter(struct ptunsigned long flags;char *trace_buf;char *raw_data; -int *recursion;int syscall_nr; +int rctx;int size;int cpu;
@@ -506,7 +506,8 @@ static void prof_syscall_enter(struct pt/* Protect the per cpu buffer, begin the rcu read side */ local_irq_save (flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; cpu =smp_processor_id ();
@@ -530,7 +531,7 @@ static void prof_syscall_enter(struct ptperf_tp_event (sys_data->enter_id,0 ,1 , rec, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (flags); }
@@ -582,7 +583,7 @@ static void prof_syscall_exit(struct pt_int syscall_nr;char *trace_buf;char *raw_data; -int *recursion; +int rctx;int size;int cpu;
@@ -609,7 +610,8 @@ static void prof_syscall_exit(struct pt_/* Protect the per cpu buffer, begin the rcu read side */ local_irq_save (flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; cpu =smp_processor_id ();
@@ -634,7 +636,7 @@ static void prof_syscall_exit(struct pt_perf_tp_event (sys_data->exit_id,0 ,1 , rec, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (flags); }
[tip:perf/core] perf_events: Undo some recursion damage
Commit-ID: 4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Gitweb: http://git.kernel.org/tip/4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:29 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:57 +0100
perf_events: Undo some recursion damage
Make perf_swevent_get_recursion_context return a context number and disable preemption.
This could be used to remove the IRQ disable from the trace bit and index the per-cpu buffer with.
LKML-Reference: <[email protected]>
--- include/linux/perf_event.h | 8 ++-- include/trace/ftrace.h | 17 +++++----- kernel/perf_event.c | 71 ++++++++++++++++++---------------------- kernel/trace/trace_kprobe.c | 14 +++++--- kernel/trace/trace_syscalls.c | 14 +++++--- 5 files changed, 61 insertions(+), 63 deletions(-)
include/linux/perf_event.h +4 -4
@@ -874,8 +874,8 @@ extern int perf_output_begin(struct perf_output_handle *handle,extern void perf_output_end (struct perf_output_handle *handle);extern void perf_output_copy (struct perf_output_handle *handle,const void *buf,unsigned int len); -extern int perf_swevent_get_recursion_context (int **recursion); -extern void perf_swevent_put_recursion_context (int *recursion); +extern int perf_swevent_get_recursion_context (void ); +extern void perf_swevent_put_recursion_context (int rctx);#else static inline void perf_event_task_sched_in (struct task_struct *task,int cpu) { }
@@ -904,8 +904,8 @@ static inline void perf_event_mmap(struct vm_area_struct *vma) { }static inline void perf_event_comm (struct task_struct *tsk) { }static inline void perf_event_fork (struct task_struct *tsk) { }static inline void perf_event_init (void ) { } -static int perf_swevent_get_recursion_context (int **recursion) {return -1 ; } -static void perf_swevent_put_recursion_context (int *recursion) { } +static inline int perf_swevent_get_recursion_context (void ) {return -1 ; } +static inline void perf_swevent_put_recursion_context (int rctx) { }#endif
include/trace/ftrace.h +9 -8
@@ -724,8 +724,8 @@ __attribute__((section("_ftrace_events"))) event_##call = { \ static void ftrace_profile_##call(proto) \ { \ struct ftrace_data_offsets_##call __maybe_unused __data_offsets;\ - extern int perf_swevent_get_recursion_context(int **recursion); \ - extern void perf_swevent_put_recursion_context(int *recursion); \ + extern int perf_swevent_get_recursion_context(void); \ + extern void perf_swevent_put_recursion_context(int rctx); \ struct ftrace_event_call *event_call = &event_##call; \ extern void perf_tp_event(int, u64, u64, void *, int); \ struct ftrace_raw_##call *entry; \
@@ -736,8 +736,8 @@ static void ftrace_profile_##call(proto) \int __data_size; \char *trace_buf; \char *raw_data; \ -int *recursion; \int __cpu; \ +int rctx; \int pc; \ \ pc =preempt_count (); \
@@ -753,8 +753,9 @@ static void ftrace_profile_##call(proto) \ \local_irq_save (irq_flags); \ \ -if (perf_swevent_get_recursion_context (&recursion)) \ - goto end_recursion; \ + rctx =perf_swevent_get_recursion_context (); \ +if (rctx <0 ) \ + goto end_recursion; \ \ __cpu =smp_processor_id (); \ \
@@ -781,9 +782,9 @@ static void ftrace_profile_##call(proto) \perf_tp_event (event_call->id, __addr, __count, entry, \ __entry_size); \ \ -end: \ -perf_swevent_put_recursion_context (recursion); \ -end_recursion: \ +end: \ +perf_swevent_put_recursion_context (rctx); \ +end_recursion: \local_irq_restore (irq_flags); \ \ }
kernel/perf_event.c +32 -39
118 lines not on this page · raw message
kernel/trace/trace_kprobe.c +8 -6
@@ -1213,7 +1213,7 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,unsigned long irq_flags;char *trace_buf;char *raw_data; -int *recursion; +int rctx; pc =preempt_count (); __size =SIZEOF_KPROBE_TRACE_ENTRY (tp->nr_args);
@@ -1229,7 +1229,8 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,*/ local_irq_save (irq_flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; __cpu =smp_processor_id ();
@@ -1258,7 +1259,7 @@ static __kprobes int kprobe_profile_func(struct kprobe *kp,perf_tp_event (call->id, entry->ip,1 , entry, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (irq_flags);
@@ -1276,8 +1277,8 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,int size, __size, i, pc, __cpu;unsigned long irq_flags;char *trace_buf; -int *recursion;char *raw_data; +int rctx; pc =preempt_count (); __size =SIZEOF_KRETPROBE_TRACE_ENTRY (tp->nr_args);
@@ -1293,7 +1294,8 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,*/ local_irq_save (irq_flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; __cpu =smp_processor_id ();
@@ -1323,7 +1325,7 @@ static __kprobes int kretprobe_profile_func(struct kretprobe_instance *ri,perf_tp_event (call->id, entry->ret_ip,1 , entry, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (irq_flags);
kernel/trace/trace_syscalls.c +8 -6
@@ -481,8 +481,8 @@ static void prof_syscall_enter(struct pt_regs *regs, long id)unsigned long flags;char *trace_buf;char *raw_data; -int *recursion;int syscall_nr; +int rctx;int size;int cpu;
@@ -506,7 +506,8 @@ static void prof_syscall_enter(struct pt_regs *regs, long id)/* Protect the per cpu buffer, begin the rcu read side */ local_irq_save (flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; cpu =smp_processor_id ();
@@ -530,7 +531,7 @@ static void prof_syscall_enter(struct pt_regs *regs, long id)perf_tp_event (sys_data->enter_id,0 ,1 , rec, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (flags); }
@@ -582,7 +583,7 @@ static void prof_syscall_exit(struct pt_regs *regs, long ret)int syscall_nr;char *trace_buf;char *raw_data; -int *recursion; +int rctx;int size;int cpu;
@@ -609,7 +610,8 @@ static void prof_syscall_exit(struct pt_regs *regs, long ret)/* Protect the per cpu buffer, begin the rcu read side */ local_irq_save (flags); -if (perf_swevent_get_recursion_context (&recursion)) + rctx =perf_swevent_get_recursion_context (); +if (rctx <0 ) goto end_recursion; cpu =smp_processor_id ();
@@ -634,7 +636,7 @@ static void prof_syscall_exit(struct pt_regs *regs, long ret)perf_tp_event (sys_data->exit_id,0 ,1 , rec, size); end: -perf_swevent_put_recursion_context (recursion); +perf_swevent_put_recursion_context (rctx); end_recursion:local_irq_restore (flags); }
Re: [tip:perf/core] perf_events: Undo some recursion damage
Quoted 7 lines · tip-bot for Peter Zijlstra
Commit-ID: 4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Gitweb: http://git.kernel.org/tip/4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:29 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:57 +0100
Quoted 7 lines
perf_events: Undo some recursion damageMake
perf_swevent_get_recursion_contextreturn a context number and disable preemption.This could be used to remove the IRQ disable from the trace bit and index the per-cpu buffer with.
But if I do that, it means I will lose traces once irq nest.
Peter Zijlstra
maintainerRe: [tip:perf/core] perf_events: Undo some recursion damage
Quoted 10 lines · Frederic Weisbecker
Quoted 9 lines · tip-bot for Peter Zijlstra
Commit-ID: 4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Gitweb: http://git.kernel.org/tip/4ed7c92d68a5387ba5f7030dc76eab03558e27f5 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 11:37:29 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 11:49:57 +0100
perf_events: Undo some recursion damage
Quoted 8 lines
Quoted 5 lines
Make
perf_swevent_get_recursion_contextreturn a context number and disable preemption.This could be used to remove the IRQ disable from the trace bit and index the per-cpu buffer with.
But if I do that, it means I will lose traces once irq nest.
Ah yes, that crap :-(
Maybe its about time we extend the generic irq bits to know about nested irqs, or firmly kill the whole notion.
RFC PATCH 8/8 perf: be paranoid about child times?
In reply to Peter ZijlstraNormally we flatten the inherited hierarchy by attaching all childs to the top parent, therefore a child's child_total_time_* should never get incremented, add it anyway?
--- kernel/perf_event.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
kernel/perf_event.c +4 -2
@@ -1780,8 +1780,10 @@ u64 perf_event_read_value(struct perf_evlist_for_each_entry (child, &event->child_list, child_list) { total +=perf_event_read (child); - *enabled += child->total_time_enabled; - *running += child->total_time_running; + *enabled += child->total_time_enabled + +atomic64_read (&child->child_total_time_enabled); + *running += child->total_time_running + +atomic64_read (&child->child_total_time_running); }mutex_unlock (&event->child_mutex);
Re: [PATCH 8/8][RFC] perf: be paranoid about child times?
Quoted 14 lines · Peter Zijlstra
Normally we flatten the inherited hierarchy by attaching all childs to the top parent, therefore a child's child_total_time_* should never get incremented, add it anyway?
Signed-off-by Peter Zijlstra <[email protected]>--- kernel/perf_event.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)Index:
linux-2.6/kernel/perf_event.c
===================================================================
kernel/perf_event.c u64 perf_event_read_value(struct perf_ev · line 1786
Quoted 9 lines
kernel/perf_event.c +4
-2@@ -1780,8 +1780,10 @@ u64 perf_event_read_value(struct perf_evlist_for_each_entry (child, &event->child_list, child_list) { total +=perf_event_read (child); - *enabled += child->total_time_enabled; - *running += child->total_time_running; + *enabled += child->total_time_enabled + +atomic64_read (&child->child_total_time_enabled); + *running += child->total_time_running + +atomic64_read (&child->child_total_time_running);
Stick in a WARN_ON_ONCE() instead?
Ingo
Peter Zijlstra
maintainer[PATCH 9/8] perf_events: Restore sanity to scaling land
In reply to Peter ZijlstraIt is quite possible to call update_event_times() on a context that isn't actually running and thereby confuse the thing.
perf stat was reporting !100% scale values for software counters (2e2af50b perf_events: Disable events when we detach them, solved the worst of that, but there was still some left).
The thing that happens is that because we are not self-reaping (we have a caring parent) there is a time between the last schedule (out) and having do_exit() called which will detach the events.
This period would be accounted as enabled,!running because the event->state==INACTIVE, even though !event->ctx->is_active.
Similar issues could have been observed by calling read() on a event while the attached task was not scheduled in.
Solve this by teaching update_event_times() about ctx->is_active.
--- kernel/perf_event.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
kernel/perf_event.c +6 -1
@@ -274,7 +274,12 @@ static void update_event_times(struct perf_event *event) event->group_leader->state < PERF_EVENT_STATE_INACTIVE)return ; - event->total_time_enabled = ctx->time - event->tstamp_enabled; +if (ctx->is_active) + run_end = ctx->time; +else + run_end = event->tstamp_stopped; + + event->total_time_enabled = run_end - event->tstamp_enabled;if (event->state ==PERF_EVENT_STATE_INACTIVE ) run_end = event->tstamp_stopped;
tip-bot for Peter Zijlstra
maintainer[tip:perf/core] perf_events: Restore sanity to scaling land
Commit-ID: acd1d7c1f8f3d848a3c5327dc09f8c1efb971678 Gitweb: http://git.kernel.org/tip/acd1d7c1f8f3d848a3c5327dc09f8c1efb971678 Author: Peter Zijlstra <[email protected]> AuthorDate: Mon, 23 Nov 2009 15:00:36 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 23 Nov 2009 15:22:19 +0100
perf_events: Restore sanity to scaling land
It is quite possible to call update_event_times() on a context that isn't actually running and thereby confuse the thing.
perf stat was reporting !100% scale values for software counters (2e2af50b perf_events: Disable events when we detach them, solved the worst of that, but there was still some left).
The thing that happens is that because we are not self-reaping (we have a caring parent) there is a time between the last schedule (out) and having do_exit() called which will detach the events.
This period would be accounted as enabled,!running because the event->state==INACTIVE, even though !event->ctx->is_active.
Similar issues could have been observed by calling read() on a event while the attached task was not scheduled in.
Solve this by teaching update_event_times() aboutctx->is_active.
LKML-Reference: <1258984836.4531.480.camel@laptop>
--- kernel/perf_event.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
kernel/perf_event.c +6 -1
@@ -274,7 +274,12 @@ static void update_event_times(struct perf_event *event) event->group_leader->state < PERF_EVENT_STATE_INACTIVE)return ; - event->total_time_enabled = ctx->time - event->tstamp_enabled; +if (ctx->is_active) + run_end = ctx->time; +else + run_end = event->tstamp_stopped; + + event->total_time_enabled = run_end - event->tstamp_enabled;if (event->state ==PERF_EVENT_STATE_INACTIVE ) run_end = event->tstamp_stopped;