linux-toradex.git/kernel/trace/trace_output.c, branch v2.6.34-rc4

tracing: Add full state to trace_seq

2009-12-09T19:05:49+00:00

The trace_seq buffer might fill up, and right now one needs to check the
return value of each printf into the buffer to check for that.

Instead, have the buffer keep track of whether it is full or not, and
reject more input if it is full or would have overflowed with an input
that wasn't added.

Cc: Lai Jiangshan 
Signed-off-by: Johannes Berg 
Signed-off-by: Steven Rostedt

tracing: Buffer the output of seq_file in case of filled buffer

2009-12-09T18:55:26+00:00

If the seq_read fills the buffer it will call s_start again on the next
itertation with the same position. This causes a problem with the
function_graph tracer because it consumes the iteration in order to
determine leaf functions.

What happens is that the iterator stores the entry, and the function
graph plugin will look at the next entry. If that next entry is a return
of the same function and task, then the function is a leaf and the
function_graph plugin calls ring_buffer_read which moves the ring buffer
iterator forward (the trace iterator still points to the function start
entry).

The copying of the trace_seq to the seq_file buffer will fail if the
seq_file buffer is full. The seq_read will not show this entry.
The next read by userspace will cause seq_read to again call s_start
which will reuse the trace iterator entry (the function start entry).
But the function return entry was already consumed. The function graph
plugin will think that this entry is a nested function and not a leaf.

To solve this, the trace code now checks the return status of the
seq_printf (trace_print_seq). If the writing to the seq_file buffer
fails, we set a flag in the iterator (leftover) and we do not reset
the trace_seq buffer. On the next call to s_start, we check the leftover
flag, and if it is set, we just reuse the trace_seq buffer and do not
call into the plugin print functions.

Before this patch:

 2)               |      fput() {
 2)               |        __fput() {
 2)   0.550 us    |          inotify_inode_queue_event();
 2)               |          __fsnotify_parent() {
 2)   0.540 us    |          inotify_dentry_parent_queue_event();

After the patch:

 2)               |      fput() {
 2)               |        __fput() {
 2)   0.550 us    |          inotify_inode_queue_event();
 2)   0.548 us    |          __fsnotify_parent();
 2)   0.540 us    |          inotify_dentry_parent_queue_event();

[
  Updated the patch to fix a missing return 0 from the trace_print_seq()
  stub when CONFIG_TRACING is disabled.

  Reported-by: Ingo Molnar 
]

Reported-by: Jiri Olsa 
Cc: Frederic Weisbecker 
Signed-off-by: Steven Rostedt

tracing: Fix trace_seq_printf() return value

2009-10-24T09:07:50+00:00

trace_seq_printf() return value is a little ambiguous. It
currently returns the length of the space available in the
buffer. printf usually returns the amount written. This is not
adequate here, because:

  trace_seq_printf(s, "");

is perfectly legal, and returning 0 would indicate that it
failed.

We can always see the amount written by looking at the before
and after values of s->len. This is not quite the same use as
printf. We only care if the string was successfully written to
the buffer or not.

Make trace_seq_printf() return 0 if the trace oversizes the
buffer's free space, 1 otherwise.

Signed-off-by: Jiri Olsa 
Signed-off-by: Steven Rostedt 
Cc: Frederic Weisbecker 
LKML-Reference: <20091023233646.631787612@goodmis.org>
Signed-off-by: Ingo Molnar

tracing: fix transposed numbers of lock_depth and preempt_count

2009-10-07T18:05:04+00:00

The lock_depth and preempt_count numbers in the latency format is
transposed.

Signed-off-by: Steven Rostedt

trace: Fix missing assignment in trace_ctxwake_*

2009-10-06T12:28:24+00:00

The state char variable S should be reassigned, if S == 0.

We are missing the state of the task that is going to sleep for the
context switch events (in the raw mode).

Fortunately the problem arises with the sched_switch/wake_up
tracers, not the sched trace events.

The formers are legacy now. But still, that was buggy.

Signed-off-by: Hiroshi Shimamoto 
Cc: Steven Rostedt 
Acked-by: Frederic Weisbecker 
LKML-Reference: <4AC43118.6050409@ct.jp.nec.com>
Signed-off-by: Ingo Molnar

tracing: consolidate code between trace_output.c and trace_function_graph.c

2009-09-11T18:24:13+00:00

Both trace_output.c and trace_function_graph.c do basically the same
thing to handle the printing of the latency-format. This patch moves
the code into one function that both can use.

Signed-off-by: Steven Rostedt

tracing: add lock depth to entries

2009-09-11T17:55:35+00:00

This patch adds the lock depth of the big kernel lock to the generic
entry header. This way we can see the depth of the lock and help
in removing the BKL.

Example:

 #                  _------=> CPU#
 #                 / _-----=> irqs-off
 #                | / _----=> need-resched
 #                || / _---=> hardirq/softirq
 #                ||| / _--=> preempt-depth
 #                |||| /_--=> lock-depth
 #                |||||/     delay
 #  cmd     pid   |||||| time  |   caller
 #     \   /      ||||||   \   |   /
   -0       2.N..3 5902255250us+: lock_acquire: read rcu_read_lock
   -0       2.N..3 5902255253us+: lock_release: rcu_read_lock
   -0       2dN..3 5902255257us+: lock_acquire: xtime_lock
   -0       2dN..4 5902255259us : lock_acquire: clocksource_lock
   -0       2dN..4 5902255261us+: lock_release: clocksource_lock

Signed-off-by: Steven Rostedt

tracing: move tgid out of generic entry and into userstack

2009-09-11T15:36:23+00:00

The userstack trace required the recording of the tgid entry.
Unfortunately, it was added to the generic entry where it wasted
4 bytes of every entry and was only used by one entry.

This patch moves it out of the generic field and moves it into the
only user (userstack_entry).

Signed-off-by: Steven Rostedt

tracing: Fix trace_print_seq()

2009-07-02T06:51:13+00:00

We will lose something if trace_seq->buffer[0] is 0, because the copy length
is calculated by strlen() in seq_puts(), so using seq_write() instead of
seq_puts().

There have a example:
after reboot:

 # echo kmemtrace > current_tracer
 # echo 0 > options/kmem_minimalistic
 # cat trace
 # tracer: kmemtrace
 #
 #

Nothing is exported, because the first byte of trace_seq->buffer[ ]
is KMEMTRACE_USER_ALLOC.

( the value of KMEMTRACE_USER_ALLOC is zero, seeing
  kmemtrace_print_alloc_user() in kernel/trace/kmemtrace.c)

Signed-off-by: Xiao Guangrong 
Acked-by: Frederic Weisbecker 
Acked-by: Pekka Enberg 
Acked-by: Eduard - Gabriel Munteanu 
Cc: Steven Rostedt 
LKML-Reference: <4A4B2351.5010300@cn.fujitsu.com>
Signed-off-by: Ingo Molnar

tracing: add protection around module events unload

2009-06-09T21:29:07+00:00

When reading the trace buffer, there is a race that when a module
is unloaded it removes events that is stilled referenced in the buffers.
This patch adds the protection around the unloading of the events
from modules and the reading of the trace buffers.

Signed-off-by: Steven Rostedt