From: Frederic Weisbecker <fweisbec@gmail.com>
To: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Cc: Steven Rostedt <rostedt@goodmis.org>, Ingo Molnar <mingo@elte.hu>,
Jens Axboe <jens.axboe@oracle.com>,
Linux Kernel Mailing List <linux-kernel@vger.kernel.org>
Subject: Re: [PATCH tip 2/2] tracing: Introduce trace_buffer_{lock_reserve,unlock_commit}
Date: Thu, 5 Feb 2009 23:58:37 +0100 [thread overview]
Message-ID: <20090205225835.GB23999@nowhere> (raw)
In-Reply-To: <20090205181413.GI17653@ghostprotocols.net>
On Thu, Feb 05, 2009 at 04:14:13PM -0200, Arnaldo Carvalho de Melo wrote:
> Impact: new API
>
> These new functions do what previously was being open coded, reducing
> the number of details ftrace plugin writers have to worry about.
>
> It also standardizes the handling of stacktrace, userstacktrace and
> other trace options we may introduce in the future.
>
> With this patch, for instance, the blk tracer (and some others already
> in the tree) can use the "userstacktrace" /d/tracing/trace_options
> facility.
>
> Cc: Ingo Molnar <mingo@elte.hu>
> Cc: Frédéric Weisbecker <fweisbec@gmail.com>
> Cc: Jens Axboe <jens.axboe@oracle.com>
> Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
> ---
> block/blktrace.c | 21 ++------
> kernel/trace/kmemtrace.c | 19 ++-----
> kernel/trace/trace.c | 94 +++++++++++++++++++++----------------
> kernel/trace/trace.h | 11 ++++
> kernel/trace/trace_boot.c | 20 ++------
> kernel/trace/trace_branch.c | 7 +--
> kernel/trace/trace_hw_branches.c | 7 +--
> kernel/trace/trace_mmiotrace.c | 20 +++-----
> kernel/trace/trace_power.c | 20 ++------
> 9 files changed, 102 insertions(+), 117 deletions(-)
>
> $ codiff /tmp/vmlinux.before /tmp/vmlinux.after
> linux-2.6-tip/kernel/trace/trace.c:
> trace_vprintk | -5
> trace_graph_return | -22
> trace_graph_entry | -26
> trace_function | -45
> __ftrace_trace_stack | -27
> ftrace_trace_userstack | -29
> tracing_sched_switch_trace | -66
> tracing_stop | +1
> trace_seq_to_user | -1
> ftrace_trace_special | -63
> ftrace_special | +1
> tracing_sched_wakeup_trace | -70
> tracing_reset_online_cpus | -1
> 13 functions changed, 2 bytes added, 355 bytes removed, diff: -353
>
> linux-2.6-tip/block/blktrace.c:
> __blk_add_trace | -58
> 1 function changed, 58 bytes removed, diff: -58
>
> linux-2.6-tip/kernel/trace/trace.c:
> trace_buffer_lock_reserve | +88
> trace_buffer_unlock_commit | +86
> 2 functions changed, 174 bytes added, diff: +174
>
> /tmp/vmlinux.after:
> 16 functions changed, 176 bytes added, 413 bytes removed, diff: -237
>
> diff --git a/block/blktrace.c b/block/blktrace.c
> index 8e52f24..834cd84 100644
> --- a/block/blktrace.c
> +++ b/block/blktrace.c
> @@ -187,19 +187,15 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes,
> cpu = raw_smp_processor_id();
>
> if (blk_tr) {
> - struct trace_entry *ent;
> tracing_record_cmdline(current);
>
> - event = ring_buffer_lock_reserve(blk_tr->buffer,
> - sizeof(*t) + pdu_len);
> + pc = preempt_count();
> + event = trace_buffer_lock_reserve(blk_tr, TRACE_BLK,
> + sizeof(*t) + pdu_len,
> + 0, pc);
Oh that's a good idea. That makes it more simple and abstract more the ring buffer
from tracing.
> if (!event)
> return;
> -
> - ent = ring_buffer_event_data(event);
> - t = (struct blk_io_trace *)ent;
> - pc = preempt_count();
> - tracing_generic_entry_update(ent, 0, pc);
> - ent->type = TRACE_BLK;
> + t = ring_buffer_event_data(event);
> goto record_it;
> }
>
> @@ -241,12 +237,7 @@ record_it:
> memcpy((void *) t + sizeof(*t), pdu_data, pdu_len);
>
> if (blk_tr) {
> - ring_buffer_unlock_commit(blk_tr->buffer, event);
> - if (pid != 0 &&
> - !(blk_tracer_flags.val & TRACE_BLK_OPT_CLASSIC) &&
> - (trace_flags & TRACE_ITER_STACKTRACE) != 0)
> - __trace_stack(blk_tr, 0, 5, pc);
> - trace_wake_up();
> + trace_buffer_unlock_commit(blk_tr, event, 0, pc);
> return;
> }
> }
> diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
> index 256749d..ae201b3 100644
> --- a/kernel/trace/kmemtrace.c
> +++ b/kernel/trace/kmemtrace.c
> @@ -276,13 +276,12 @@ void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
> if (!kmem_tracing_enabled)
> return;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
> + sizeof(*entry), 0, 0);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
>
> - entry->ent.type = TRACE_KMEM_ALLOC;
> entry->call_site = call_site;
> entry->ptr = ptr;
> entry->bytes_req = bytes_req;
> @@ -290,9 +289,7 @@ void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
> entry->gfp_flags = gfp_flags;
> entry->node = node;
>
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> }
> EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
>
> @@ -307,20 +304,16 @@ void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
> if (!kmem_tracing_enabled)
> return;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
> + sizeof(*entry), 0, 0);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
> -
> - entry->ent.type = TRACE_KMEM_FREE;
> entry->type_id = type_id;
> entry->call_site = call_site;
> entry->ptr = ptr;
>
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> }
> EXPORT_SYMBOL(kmemtrace_mark_free);
>
> diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
> index eb453a2..8fad377 100644
> --- a/kernel/trace/trace.c
> +++ b/kernel/trace/trace.c
> @@ -776,6 +776,39 @@ tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
> (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
> }
>
> +struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
> + unsigned char type,
> + unsigned long len,
> + unsigned long flags, int pc)
> +{
> + struct ring_buffer_event *event;
> +
> + event = ring_buffer_lock_reserve(tr->buffer, len);
> + if (event != NULL) {
> + struct trace_entry *ent = ring_buffer_event_data(event);
> +
> + tracing_generic_entry_update(ent, flags, pc);
> + ent->type = type;
> + }
> +
> + return event;
> +}
> +static void ftrace_trace_stack(struct trace_array *tr,
> + unsigned long flags, int skip, int pc);
> +static void ftrace_trace_userstack(struct trace_array *tr,
> + unsigned long flags, int pc);
> +
> +void trace_buffer_unlock_commit(struct trace_array *tr,
> + struct ring_buffer_event *event,
> + unsigned long flags, int pc)
> +{
> + ring_buffer_unlock_commit(tr->buffer, event);
> +
> + ftrace_trace_stack(tr, flags, 6, pc);
> + ftrace_trace_userstack(tr, flags, pc);
> + trace_wake_up();
> +}
I have mitigate feelings about this part. The name of this function could
have some sense if _most_ of the tracers were using the stack traces. But that's
not the case.
We have now this couple:
_ trace_buffer_lock_reserve() -> handles the ring-buffer reservation, the context info, and the type
_ trace_buffer_unlock_commit() -> unlock, commit, wake and... stacktraces?
In my opinion, the latter doesn't follow the logic meaning of the first.
And the result is a mixup of (trace_buffer | ring_buffer)(lock/unlock/reserve/commit).
You are sometimes using trace_buffer_lock_reserve followed by ring_buffer_unlock_commit.
That looks a bit weird: we are using a high level function followed by its conclusion
on the form of the low lovel function.
I think the primary role of this new couple should be to simplify the low level ring buffer
bits as it does. But the stack things should stay separated.
> +
> void
> trace_function(struct trace_array *tr,
> unsigned long ip, unsigned long parent_ip, unsigned long flags,
> @@ -788,12 +821,11 @@ trace_function(struct trace_array *tr,
> if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
> return;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_FN, sizeof(*entry),
> + flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_FN;
> entry->ip = ip;
> entry->parent_ip = parent_ip;
> ring_buffer_unlock_commit(tr->buffer, event);
> @@ -811,12 +843,11 @@ static void __trace_graph_entry(struct trace_array *tr,
> if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
> return;
>
> - event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_ENT,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_GRAPH_ENT;
> entry->graph_ent = *trace;
> ring_buffer_unlock_commit(global_trace.buffer, event);
> }
> @@ -832,12 +863,11 @@ static void __trace_graph_return(struct trace_array *tr,
> if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
> return;
>
> - event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(&global_trace, TRACE_GRAPH_RET,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_GRAPH_RET;
> entry->ret = *trace;
> ring_buffer_unlock_commit(global_trace.buffer, event);
> }
> @@ -861,13 +891,11 @@ static void __ftrace_trace_stack(struct trace_array *tr,
> struct stack_entry *entry;
> struct stack_trace trace;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_STACK,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_STACK;
> -
> memset(&entry->caller, 0, sizeof(entry->caller));
>
> trace.nr_entries = 0;
> @@ -908,12 +936,11 @@ static void ftrace_trace_userstack(struct trace_array *tr,
> if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
> return;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_USER_STACK,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_USER_STACK;
>
> memset(&entry->caller, 0, sizeof(entry->caller));
>
> @@ -941,20 +968,15 @@ ftrace_trace_special(void *__tr,
> struct trace_array *tr = __tr;
> struct special_entry *entry;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_SPECIAL,
> + sizeof(*entry), 0, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, pc);
> - entry->ent.type = TRACE_SPECIAL;
> entry->arg1 = arg1;
> entry->arg2 = arg2;
> entry->arg3 = arg3;
> - ring_buffer_unlock_commit(tr->buffer, event);
> - ftrace_trace_stack(tr, 0, 4, pc);
> - ftrace_trace_userstack(tr, 0, pc);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, 0, pc);
> }
>
> void
> @@ -973,12 +995,11 @@ tracing_sched_switch_trace(struct trace_array *tr,
> struct ring_buffer_event *event;
> struct ctx_switch_entry *entry;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_CTX,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_CTX;
> entry->prev_pid = prev->pid;
> entry->prev_prio = prev->prio;
> entry->prev_state = prev->state;
> @@ -986,9 +1007,7 @@ tracing_sched_switch_trace(struct trace_array *tr,
> entry->next_prio = next->prio;
> entry->next_state = next->state;
> entry->next_cpu = task_cpu(next);
> - ring_buffer_unlock_commit(tr->buffer, event);
> - ftrace_trace_stack(tr, flags, 5, pc);
> - ftrace_trace_userstack(tr, flags, pc);
> + trace_buffer_unlock_commit(tr, event, flags, pc);
> }
>
> void
> @@ -1000,12 +1019,11 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
> struct ring_buffer_event *event;
> struct ctx_switch_entry *entry;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_WAKE,
> + sizeof(*entry), flags, pc);
> if (!event)
> return;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_WAKE;
> entry->prev_pid = curr->pid;
> entry->prev_prio = curr->prio;
> entry->prev_state = curr->state;
> @@ -1013,11 +1031,7 @@ tracing_sched_wakeup_trace(struct trace_array *tr,
> entry->next_prio = wakee->prio;
> entry->next_state = wakee->state;
> entry->next_cpu = task_cpu(wakee);
> - ring_buffer_unlock_commit(tr->buffer, event);
> - ftrace_trace_stack(tr, flags, 6, pc);
> - ftrace_trace_userstack(tr, flags, pc);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, flags, pc);
> }
>
> void
> @@ -2825,12 +2839,10 @@ int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
> trace_buf[len] = 0;
>
> size = sizeof(*entry) + len + 1;
> - event = ring_buffer_lock_reserve(tr->buffer, size);
> + event = trace_buffer_lock_reserve(tr, TRACE_PRINT, size, irq_flags, pc);
> if (!event)
> goto out_unlock;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, irq_flags, pc);
> - entry->ent.type = TRACE_PRINT;
> entry->ip = ip;
> entry->depth = depth;
>
> diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
> index df627a9..e03f157 100644
> --- a/kernel/trace/trace.h
> +++ b/kernel/trace/trace.h
> @@ -403,6 +403,17 @@ int tracing_open_generic(struct inode *inode, struct file *filp);
> struct dentry *tracing_init_dentry(void);
> void init_tracer_sysprof_debugfs(struct dentry *d_tracer);
>
> +struct ring_buffer_event;
> +
> +struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr,
> + unsigned char type,
> + unsigned long len,
> + unsigned long flags,
> + int pc);
> +void trace_buffer_unlock_commit(struct trace_array *tr,
> + struct ring_buffer_event *event,
> + unsigned long flags, int pc);
> +
> struct trace_entry *tracing_get_trace_entry(struct trace_array *tr,
> struct trace_array_cpu *data);
>
> diff --git a/kernel/trace/trace_boot.c b/kernel/trace/trace_boot.c
> index 4e08deb..7a30fc4 100644
> --- a/kernel/trace/trace_boot.c
> +++ b/kernel/trace/trace_boot.c
> @@ -143,17 +143,13 @@ void trace_boot_call(struct boot_trace_call *bt, initcall_t fn)
> sprint_symbol(bt->func, (unsigned long)fn);
> preempt_disable();
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_BOOT_CALL,
> + sizeof(*entry), 0, 0);
> if (!event)
> goto out;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
> - entry->ent.type = TRACE_BOOT_CALL;
> entry->boot_call = *bt;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> -
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> out:
> preempt_enable();
> }
> @@ -170,17 +166,13 @@ void trace_boot_ret(struct boot_trace_ret *bt, initcall_t fn)
> sprint_symbol(bt->func, (unsigned long)fn);
> preempt_disable();
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_BOOT_RET,
> + sizeof(*entry), 0, 0);
> if (!event)
> goto out;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
> - entry->ent.type = TRACE_BOOT_RET;
> entry->boot_ret = *bt;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> -
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> out:
> preempt_enable();
> }
> diff --git a/kernel/trace/trace_branch.c b/kernel/trace/trace_branch.c
> index 770e52a..48b2196 100644
> --- a/kernel/trace/trace_branch.c
> +++ b/kernel/trace/trace_branch.c
> @@ -52,14 +52,13 @@ probe_likely_condition(struct ftrace_branch_data *f, int val, int expect)
> if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
> goto out;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + pc = preempt_count();
> + event = trace_buffer_lock_reserve(tr, TRACE_BRANCH,
> + sizeof(*entry), flags, pc);
> if (!event)
> goto out;
>
> - pc = preempt_count();
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, flags, pc);
> - entry->ent.type = TRACE_BRANCH;
>
> /* Strip off the path, only save the file */
> p = f->file + strlen(f->file);
> diff --git a/kernel/trace/trace_hw_branches.c b/kernel/trace/trace_hw_branches.c
> index e720c00..2aa1c9f 100644
> --- a/kernel/trace/trace_hw_branches.c
> +++ b/kernel/trace/trace_hw_branches.c
> @@ -189,16 +189,15 @@ void trace_hw_branch(u64 from, u64 to)
> if (atomic_inc_return(&tr->data[cpu]->disabled) != 1)
> goto out;
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_HW_BRANCHES,
> + sizeof(*entry), 0, 0);
> if (!event)
> goto out;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, from);
> - entry->ent.type = TRACE_HW_BRANCHES;
> entry->ent.cpu = cpu;
> entry->from = from;
> entry->to = to;
> - ring_buffer_unlock_commit(tr->buffer, event);
> + trace_buffer_unlock_commit(tr, event, 0, 0);
>
> out:
> atomic_dec(&tr->data[cpu]->disabled);
> diff --git a/kernel/trace/trace_mmiotrace.c b/kernel/trace/trace_mmiotrace.c
> index 104ddeb..c401b90 100644
> --- a/kernel/trace/trace_mmiotrace.c
> +++ b/kernel/trace/trace_mmiotrace.c
> @@ -307,19 +307,17 @@ static void __trace_mmiotrace_rw(struct trace_array *tr,
> {
> struct ring_buffer_event *event;
> struct trace_mmiotrace_rw *entry;
> + int pc = preempt_count();
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_MMIO_RW,
> + sizeof(*entry), 0, pc);
> if (!event) {
> atomic_inc(&dropped_count);
> return;
> }
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, preempt_count());
> - entry->ent.type = TRACE_MMIO_RW;
> entry->rw = *rw;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, 0, pc);
> }
>
> void mmio_trace_rw(struct mmiotrace_rw *rw)
> @@ -335,19 +333,17 @@ static void __trace_mmiotrace_map(struct trace_array *tr,
> {
> struct ring_buffer_event *event;
> struct trace_mmiotrace_map *entry;
> + int pc = preempt_count();
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_MMIO_MAP,
> + sizeof(*entry), 0, pc);
> if (!event) {
> atomic_inc(&dropped_count);
> return;
> }
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, preempt_count());
> - entry->ent.type = TRACE_MMIO_MAP;
> entry->map = *map;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> + trace_buffer_unlock_commit(tr, event, 0, pc);
> }
>
> void mmio_trace_mapping(struct mmiotrace_map *map)
> diff --git a/kernel/trace/trace_power.c b/kernel/trace/trace_power.c
> index 3b1a292..bfc21f8 100644
> --- a/kernel/trace/trace_power.c
> +++ b/kernel/trace/trace_power.c
> @@ -124,17 +124,13 @@ void trace_power_end(struct power_trace *it)
> it->end = ktime_get();
> data = tr->data[smp_processor_id()];
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_POWER,
> + sizeof(*entry), 0, 0);
> if (!event)
> goto out;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
> - entry->ent.type = TRACE_POWER;
> entry->state_data = *it;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> -
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> out:
> preempt_enable();
> }
> @@ -159,17 +155,13 @@ void trace_power_mark(struct power_trace *it, unsigned int type,
> it->end = it->stamp;
> data = tr->data[smp_processor_id()];
>
> - event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
> + event = trace_buffer_lock_reserve(tr, TRACE_POWER,
> + sizeof(*entry), 0, 0);
> if (!event)
> goto out;
> entry = ring_buffer_event_data(event);
> - tracing_generic_entry_update(&entry->ent, 0, 0);
> - entry->ent.type = TRACE_POWER;
> entry->state_data = *it;
> - ring_buffer_unlock_commit(tr->buffer, event);
> -
> - trace_wake_up();
> -
> + trace_buffer_unlock_commit(tr, event, 0, 0);
> out:
> preempt_enable();
> }
> --
> 1.6.0.6
>
Other than what I said above, I find it a very valuable cleanup.
Thanks.
Frederic.
next prev parent reply other threads:[~2009-02-05 22:59 UTC|newest]
Thread overview: 8+ messages / expand[flat|nested] mbox.gz Atom feed top
2009-02-05 18:14 [PATCH tip 2/2] tracing: Introduce trace_buffer_{lock_reserve,unlock_commit} Arnaldo Carvalho de Melo
2009-02-05 22:58 ` Frederic Weisbecker [this message]
2009-02-06 1:54 ` Arnaldo Carvalho de Melo
2009-02-06 2:39 ` Frederic Weisbecker
2009-02-06 3:10 ` Arnaldo Carvalho de Melo
2009-02-08 13:04 ` Frederic Weisbecker
2009-02-08 15:17 ` Steven Rostedt
2009-02-06 0:02 ` Ingo Molnar
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20090205225835.GB23999@nowhere \
--to=fweisbec@gmail.com \
--cc=acme@ghostprotocols.net \
--cc=jens.axboe@oracle.com \
--cc=linux-kernel@vger.kernel.org \
--cc=mingo@elte.hu \
--cc=rostedt@goodmis.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.