blob: fca0233f1d73db078614d6dca5e4c6a96808ecda [file] [log] [blame]
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001/*
2 * ring buffer based function tracer
3 *
4 * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
5 * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com>
6 *
7 * Originally taken from the RT patch by:
8 * Arnaldo Carvalho de Melo <acme@redhat.com>
9 *
10 * Based on code from the latency_tracer, that is:
11 * Copyright (C) 2004-2006 Ingo Molnar
12 * Copyright (C) 2004 William Lee Irwin III
13 */
14#include <linux/utsrelease.h>
15#include <linux/kallsyms.h>
16#include <linux/seq_file.h>
Steven Rostedt3f5a54e2008-07-30 22:36:46 -040017#include <linux/notifier.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020018#include <linux/debugfs.h>
Steven Rostedt4c11d7a2008-05-12 21:20:43 +020019#include <linux/pagemap.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020020#include <linux/hardirq.h>
21#include <linux/linkage.h>
22#include <linux/uaccess.h>
23#include <linux/ftrace.h>
24#include <linux/module.h>
25#include <linux/percpu.h>
Steven Rostedt3f5a54e2008-07-30 22:36:46 -040026#include <linux/kdebug.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020027#include <linux/ctype.h>
28#include <linux/init.h>
Soeren Sandmann Pedersen2a2cc8f2008-05-12 21:20:49 +020029#include <linux/poll.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020030#include <linux/gfp.h>
31#include <linux/fs.h>
Abhishek Sagar76094a22008-05-28 00:03:18 +053032#include <linux/kprobes.h>
Török Edwinb54d3de2008-11-22 13:28:48 +020033#include <linux/seq_file.h>
Steven Rostedt3eefae92008-05-12 21:21:04 +020034#include <linux/writeback.h>
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020035
Ingo Molnar86387f72008-05-12 21:20:51 +020036#include <linux/stacktrace.h>
Steven Rostedt3928a8a2008-09-29 23:02:41 -040037#include <linux/ring_buffer.h>
Frederic Weisbecker21798a82008-10-28 09:43:26 +010038#include <linux/irqflags.h>
Ingo Molnar86387f72008-05-12 21:20:51 +020039
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020040#include "trace.h"
41
Steven Rostedt3928a8a2008-09-29 23:02:41 -040042#define TRACE_BUFFER_FLAGS (RB_FL_OVERWRITE)
43
Steven Rostedtbc0c38d2008-05-12 21:20:42 +020044unsigned long __read_mostly tracing_max_latency = (cycle_t)ULONG_MAX;
45unsigned long __read_mostly tracing_thresh;
46
Frederic Weisbecker8e1b82e2008-12-06 03:41:33 +010047/*
48 * We need to change this state when a selftest is running.
Frederic Weisbeckerff325042008-12-04 23:47:35 +010049 * A selftest will lurk into the ring-buffer to count the
50 * entries inserted during the selftest although some concurrent
51 * insertions into the ring-buffer such as ftrace_printk could occurred
52 * at the same time, giving false positive or negative results.
53 */
Frederic Weisbecker8e1b82e2008-12-06 03:41:33 +010054static bool __read_mostly tracing_selftest_running;
Frederic Weisbeckerff325042008-12-04 23:47:35 +010055
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +010056/* For tracers that don't implement custom flags */
57static struct tracer_opt dummy_tracer_opt[] = {
58 { }
59};
60
61static struct tracer_flags dummy_tracer_flags = {
62 .val = 0,
63 .opts = dummy_tracer_opt
64};
65
66static int dummy_set_flag(u32 old_flags, u32 bit, int set)
67{
68 return 0;
69}
Steven Rostedt0f048702008-11-05 16:05:44 -050070
71/*
72 * Kill all tracing for good (never come back).
73 * It is initialized to 1 but will turn to zero if the initialization
74 * of the tracer is successful. But that is the only place that sets
75 * this back to zero.
76 */
77int tracing_disabled = 1;
78
Steven Rostedtd7690412008-10-01 00:29:53 -040079static DEFINE_PER_CPU(local_t, ftrace_cpu_disabled);
80
81static inline void ftrace_disable_cpu(void)
82{
83 preempt_disable();
84 local_inc(&__get_cpu_var(ftrace_cpu_disabled));
85}
86
87static inline void ftrace_enable_cpu(void)
88{
89 local_dec(&__get_cpu_var(ftrace_cpu_disabled));
90 preempt_enable();
91}
92
Steven Rostedtab464282008-05-12 21:21:00 +020093static cpumask_t __read_mostly tracing_buffer_mask;
94
95#define for_each_tracing_cpu(cpu) \
96 for_each_cpu_mask(cpu, tracing_buffer_mask)
97
Steven Rostedt944ac422008-10-23 19:26:08 -040098/*
99 * ftrace_dump_on_oops - variable to dump ftrace buffer on oops
100 *
101 * If there is an oops (or kernel panic) and the ftrace_dump_on_oops
102 * is set, then ftrace_dump is called. This will output the contents
103 * of the ftrace buffers to the console. This is very useful for
104 * capturing traces that lead to crashes and outputing it to a
105 * serial console.
106 *
107 * It is default off, but you can enable it with either specifying
108 * "ftrace_dump_on_oops" in the kernel command line, or setting
109 * /proc/sys/kernel/ftrace_dump_on_oops to true.
110 */
111int ftrace_dump_on_oops;
112
Peter Zijlstrad9e54072008-11-01 19:57:37 +0100113static int tracing_set_tracer(char *buf);
114
115static int __init set_ftrace(char *str)
116{
117 tracing_set_tracer(str);
118 return 1;
119}
120__setup("ftrace", set_ftrace);
121
Steven Rostedt944ac422008-10-23 19:26:08 -0400122static int __init set_ftrace_dump_on_oops(char *str)
123{
124 ftrace_dump_on_oops = 1;
125 return 1;
126}
127__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops);
Steven Rostedt60a11772008-05-12 21:20:44 +0200128
Thomas Gleixner72829bc2008-05-23 21:37:28 +0200129long
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200130ns2usecs(cycle_t nsec)
131{
132 nsec += 500;
133 do_div(nsec, 1000);
134 return nsec;
135}
136
Ingo Molnare309b412008-05-12 21:20:51 +0200137cycle_t ftrace_now(int cpu)
Ingo Molnar750ed1a2008-05-12 21:20:46 +0200138{
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400139 u64 ts = ring_buffer_time_stamp(cpu);
140 ring_buffer_normalize_time_stamp(cpu, &ts);
141 return ts;
Ingo Molnar750ed1a2008-05-12 21:20:46 +0200142}
143
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200144/*
145 * The global_trace is the descriptor that holds the tracing
146 * buffers for the live tracing. For each CPU, it contains
147 * a link list of pages that will store trace entries. The
148 * page descriptor of the pages in the memory is used to hold
149 * the link list by linking the lru item in the page descriptor
150 * to each of the pages in the buffer per CPU.
151 *
152 * For each active CPU there is a data field that holds the
153 * pages for the buffer for that CPU. Each CPU has the same number
154 * of pages allocated for its buffer.
155 */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200156static struct trace_array global_trace;
157
158static DEFINE_PER_CPU(struct trace_array_cpu, global_trace_cpu);
159
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200160/*
161 * The max_tr is used to snapshot the global_trace when a maximum
162 * latency is reached. Some tracers will use this to store a maximum
163 * trace while it continues examining live traces.
164 *
165 * The buffers for the max_tr are set up the same as the global_trace.
166 * When a snapshot is taken, the link list of the max_tr is swapped
167 * with the link list of the global_trace and the buffers are reset for
168 * the global_trace so the tracing can continue.
169 */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200170static struct trace_array max_tr;
171
172static DEFINE_PER_CPU(struct trace_array_cpu, max_data);
173
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200174/* tracer_enabled is used to toggle activation of a tracer */
Steven Rostedt26994ea2008-05-12 21:20:48 +0200175static int tracer_enabled = 1;
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200176
Steven Rostedt90369902008-11-05 16:05:44 -0500177/**
178 * tracing_is_enabled - return tracer_enabled status
179 *
180 * This function is used by other tracers to know the status
181 * of the tracer_enabled flag. Tracers may use this function
182 * to know if it should enable their features when starting
183 * up. See irqsoff tracer for an example (start_irqsoff_tracer).
184 */
185int tracing_is_enabled(void)
186{
187 return tracer_enabled;
188}
189
Steven Rostedt60bc0802008-07-10 20:58:16 -0400190/* function tracing enabled */
191int ftrace_function_enabled;
192
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200193/*
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400194 * trace_buf_size is the size in bytes that is allocated
195 * for a buffer. Note, the number of bytes is always rounded
196 * to page size.
Steven Rostedt3f5a54e2008-07-30 22:36:46 -0400197 *
198 * This number is purposely set to a low number of 16384.
199 * If the dump on oops happens, it will be much appreciated
200 * to not have to wait for all that output. Anyway this can be
201 * boot time and run time configurable.
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200202 */
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400203#define TRACE_BUF_SIZE_DEFAULT 1441792UL /* 16384 * 88 (sizeof(entry)) */
Steven Rostedt3f5a54e2008-07-30 22:36:46 -0400204
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400205static unsigned long trace_buf_size = TRACE_BUF_SIZE_DEFAULT;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200206
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200207/* trace_types holds a link list of available tracers. */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200208static struct tracer *trace_types __read_mostly;
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200209
210/* current_trace points to the tracer that is currently active */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200211static struct tracer *current_trace __read_mostly;
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200212
213/*
214 * max_tracer_type_len is used to simplify the allocating of
215 * buffers to read userspace tracer names. We keep track of
216 * the longest tracer name registered.
217 */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200218static int max_tracer_type_len;
219
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200220/*
221 * trace_types_lock is used to protect the trace_types list.
222 * This lock is also used to keep user access serialized.
223 * Accesses from userspace will grab this lock while userspace
224 * activities happen inside the kernel.
225 */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200226static DEFINE_MUTEX(trace_types_lock);
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200227
228/* trace_wait is a waitqueue for tasks blocked on trace_poll */
Ingo Molnar4e655512008-05-12 21:20:52 +0200229static DECLARE_WAIT_QUEUE_HEAD(trace_wait);
230
Steven Rostedtee6bce52008-11-12 17:52:37 -0500231/* trace_flags holds trace_options default values */
Steven Rostedt12ef7d42008-11-12 17:52:38 -0500232unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |
233 TRACE_ITER_ANNOTATE;
Ingo Molnar4e655512008-05-12 21:20:52 +0200234
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200235/**
236 * trace_wake_up - wake up tasks waiting for trace input
237 *
238 * Simply wakes up any task that is blocked on the trace_wait
239 * queue. These is used with trace_poll for tasks polling the trace.
240 */
Ingo Molnar4e655512008-05-12 21:20:52 +0200241void trace_wake_up(void)
242{
Ingo Molnar017730c2008-05-12 21:20:52 +0200243 /*
244 * The runqueue_is_locked() can fail, but this is the best we
245 * have for now:
246 */
247 if (!(trace_flags & TRACE_ITER_BLOCK) && !runqueue_is_locked())
Ingo Molnar4e655512008-05-12 21:20:52 +0200248 wake_up(&trace_wait);
249}
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200250
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400251static int __init set_buf_size(char *str)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200252{
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400253 unsigned long buf_size;
Steven Rostedtc6caeeb2008-05-12 21:21:00 +0200254 int ret;
255
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200256 if (!str)
257 return 0;
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400258 ret = strict_strtoul(str, 0, &buf_size);
Steven Rostedtc6caeeb2008-05-12 21:21:00 +0200259 /* nr_entries can not be zero */
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400260 if (ret < 0 || buf_size == 0)
Steven Rostedtc6caeeb2008-05-12 21:21:00 +0200261 return 0;
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400262 trace_buf_size = buf_size;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200263 return 1;
264}
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400265__setup("trace_buf_size=", set_buf_size);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200266
Steven Rostedt57f50be2008-05-12 21:20:44 +0200267unsigned long nsecs_to_usecs(unsigned long nsecs)
268{
269 return nsecs / 1000;
270}
271
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200272/* These must match the bit postions in trace_iterator_flags */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200273static const char *trace_options[] = {
274 "print-parent",
275 "sym-offset",
276 "sym-addr",
277 "verbose",
Ingo Molnarf9896bf2008-05-12 21:20:47 +0200278 "raw",
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200279 "hex",
Ingo Molnarcb0f12a2008-05-12 21:20:47 +0200280 "bin",
Soeren Sandmann Pedersen2a2cc8f2008-05-12 21:20:49 +0200281 "block",
Ingo Molnar86387f72008-05-12 21:20:51 +0200282 "stacktrace",
Ingo Molnar4ac3ba42008-05-12 21:20:52 +0200283 "sched-tree",
Peter Zijlstraf09ce572008-09-04 10:24:14 +0200284 "ftrace_printk",
Steven Rostedtb2a866f2008-11-03 23:15:57 -0500285 "ftrace_preempt",
Steven Rostedt9f029e82008-11-12 15:24:24 -0500286 "branch",
Steven Rostedt12ef7d42008-11-12 17:52:38 -0500287 "annotate",
Török Edwin02b67512008-11-22 13:28:47 +0200288 "userstacktrace",
Török Edwinb54d3de2008-11-22 13:28:48 +0200289 "sym-userobj",
Frederic Weisbecker66896a82008-12-13 20:18:13 +0100290 "printk-msg-only",
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200291 NULL
292};
293
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200294/*
295 * ftrace_max_lock is used to protect the swapping of buffers
296 * when taking a max snapshot. The buffers themselves are
297 * protected by per_cpu spinlocks. But the action of the swap
298 * needs its own lock.
299 *
300 * This is defined as a raw_spinlock_t in order to help
301 * with performance when lockdep debugging is enabled.
302 */
Steven Rostedt92205c22008-05-12 21:20:55 +0200303static raw_spinlock_t ftrace_max_lock =
304 (raw_spinlock_t)__RAW_SPIN_LOCK_UNLOCKED;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200305
306/*
307 * Copy the new maximum trace into the separate maximum-trace
308 * structure. (this way the maximum trace is permanently saved,
309 * for later retrieval via /debugfs/tracing/latency_trace)
310 */
Ingo Molnare309b412008-05-12 21:20:51 +0200311static void
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200312__update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
313{
314 struct trace_array_cpu *data = tr->data[cpu];
315
316 max_tr.cpu = cpu;
317 max_tr.time_start = data->preempt_timestamp;
318
319 data = max_tr.data[cpu];
320 data->saved_latency = tracing_max_latency;
321
322 memcpy(data->comm, tsk->comm, TASK_COMM_LEN);
323 data->pid = tsk->pid;
David Howellsb6dff3e2008-11-14 10:39:16 +1100324 data->uid = task_uid(tsk);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200325 data->nice = tsk->static_prio - 20 - MAX_RT_PRIO;
326 data->policy = tsk->policy;
327 data->rt_priority = tsk->rt_priority;
328
329 /* record this tasks comm */
330 tracing_record_cmdline(current);
331}
332
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200333/**
334 * trace_seq_printf - sequence printing of trace information
335 * @s: trace sequence descriptor
336 * @fmt: printf format string
337 *
338 * The tracer may use either sequence operations or its own
339 * copy to user routines. To simplify formating of a trace
340 * trace_seq_printf is used to store strings into a special
341 * buffer (@s). Then the output may be either used by
342 * the sequencer or pulled into another buffer.
343 */
Thomas Gleixner72829bc2008-05-23 21:37:28 +0200344int
Steven Rostedt214023c2008-05-12 21:20:46 +0200345trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
346{
347 int len = (PAGE_SIZE - 1) - s->len;
348 va_list ap;
Steven Rostedtb3806b42008-05-12 21:20:46 +0200349 int ret;
Steven Rostedt214023c2008-05-12 21:20:46 +0200350
351 if (!len)
352 return 0;
353
354 va_start(ap, fmt);
Steven Rostedtb3806b42008-05-12 21:20:46 +0200355 ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
Steven Rostedt214023c2008-05-12 21:20:46 +0200356 va_end(ap);
357
Steven Rostedtb3806b42008-05-12 21:20:46 +0200358 /* If we can't write it all, don't bother writing anything */
Thomas Gleixner72829bc2008-05-23 21:37:28 +0200359 if (ret >= len)
Steven Rostedtb3806b42008-05-12 21:20:46 +0200360 return 0;
361
362 s->len += ret;
Steven Rostedt214023c2008-05-12 21:20:46 +0200363
364 return len;
365}
366
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200367/**
368 * trace_seq_puts - trace sequence printing of simple string
369 * @s: trace sequence descriptor
370 * @str: simple string to record
371 *
372 * The tracer may use either the sequence operations or its own
373 * copy to user routines. This function records a simple string
374 * into a special buffer (@s) for later retrieval by a sequencer
375 * or other mechanism.
376 */
Ingo Molnare309b412008-05-12 21:20:51 +0200377static int
Steven Rostedt214023c2008-05-12 21:20:46 +0200378trace_seq_puts(struct trace_seq *s, const char *str)
379{
380 int len = strlen(str);
381
382 if (len > ((PAGE_SIZE - 1) - s->len))
Steven Rostedtb3806b42008-05-12 21:20:46 +0200383 return 0;
Steven Rostedt214023c2008-05-12 21:20:46 +0200384
385 memcpy(s->buffer + s->len, str, len);
386 s->len += len;
387
388 return len;
389}
390
Ingo Molnare309b412008-05-12 21:20:51 +0200391static int
Steven Rostedt214023c2008-05-12 21:20:46 +0200392trace_seq_putc(struct trace_seq *s, unsigned char c)
393{
394 if (s->len >= (PAGE_SIZE - 1))
395 return 0;
396
397 s->buffer[s->len++] = c;
398
399 return 1;
400}
401
Ingo Molnare309b412008-05-12 21:20:51 +0200402static int
Ingo Molnarcb0f12a2008-05-12 21:20:47 +0200403trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)
404{
405 if (len > ((PAGE_SIZE - 1) - s->len))
406 return 0;
407
408 memcpy(s->buffer + s->len, mem, len);
409 s->len += len;
410
411 return len;
412}
413
Harvey Harrisonad0a3b62008-10-08 17:44:55 -0700414#define MAX_MEMHEX_BYTES 8
415#define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1)
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200416
Ingo Molnare309b412008-05-12 21:20:51 +0200417static int
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200418trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
419{
420 unsigned char hex[HEX_CHARS];
Thomas Gleixner93dcc6e2008-05-12 21:21:00 +0200421 unsigned char *data = mem;
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200422 int i, j;
423
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200424#ifdef __BIG_ENDIAN
425 for (i = 0, j = 0; i < len; i++) {
426#else
427 for (i = len-1, j = 0; i >= 0; i--) {
428#endif
Harvey Harrison2fbc4742008-10-08 16:51:49 -0700429 hex[j++] = hex_asc_hi(data[i]);
430 hex[j++] = hex_asc_lo(data[i]);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200431 }
Thomas Gleixner93dcc6e2008-05-12 21:21:00 +0200432 hex[j++] = ' ';
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +0200433
434 return trace_seq_putmem(s, hex, j);
435}
436
Török Edwinb54d3de2008-11-22 13:28:48 +0200437static int
438trace_seq_path(struct trace_seq *s, struct path *path)
439{
440 unsigned char *p;
441
442 if (s->len >= (PAGE_SIZE - 1))
443 return 0;
444 p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
445 if (!IS_ERR(p)) {
446 p = mangle_path(s->buffer + s->len, p, "\n");
447 if (p) {
448 s->len = p - s->buffer;
449 return 1;
450 }
451 } else {
452 s->buffer[s->len++] = '?';
453 return 1;
454 }
455
456 return 0;
457}
458
Ingo Molnare309b412008-05-12 21:20:51 +0200459static void
Steven Rostedt214023c2008-05-12 21:20:46 +0200460trace_seq_reset(struct trace_seq *s)
461{
462 s->len = 0;
Pekka Paalanen6c6c2792008-05-12 21:21:02 +0200463 s->readpos = 0;
464}
465
466ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
467{
468 int len;
469 int ret;
470
471 if (s->len <= s->readpos)
472 return -EBUSY;
473
474 len = s->len - s->readpos;
475 if (cnt > len)
476 cnt = len;
477 ret = copy_to_user(ubuf, s->buffer + s->readpos, cnt);
478 if (ret)
479 return -EFAULT;
480
481 s->readpos += len;
482 return cnt;
Steven Rostedt214023c2008-05-12 21:20:46 +0200483}
484
Ingo Molnare309b412008-05-12 21:20:51 +0200485static void
Steven Rostedt214023c2008-05-12 21:20:46 +0200486trace_print_seq(struct seq_file *m, struct trace_seq *s)
487{
488 int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;
489
490 s->buffer[len] = 0;
491 seq_puts(m, s->buffer);
492
493 trace_seq_reset(s);
494}
495
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200496/**
497 * update_max_tr - snapshot all trace buffers from global_trace to max_tr
498 * @tr: tracer
499 * @tsk: the task with the latency
500 * @cpu: The cpu that initiated the trace.
501 *
502 * Flip the buffers between the @tr and the max_tr and record information
503 * about which task was the cause of this latency.
504 */
Ingo Molnare309b412008-05-12 21:20:51 +0200505void
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200506update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu)
507{
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400508 struct ring_buffer *buf = tr->buffer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200509
Steven Rostedt4c11d7a2008-05-12 21:20:43 +0200510 WARN_ON_ONCE(!irqs_disabled());
Steven Rostedt92205c22008-05-12 21:20:55 +0200511 __raw_spin_lock(&ftrace_max_lock);
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400512
513 tr->buffer = max_tr.buffer;
514 max_tr.buffer = buf;
515
Steven Rostedtd7690412008-10-01 00:29:53 -0400516 ftrace_disable_cpu();
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400517 ring_buffer_reset(tr->buffer);
Steven Rostedtd7690412008-10-01 00:29:53 -0400518 ftrace_enable_cpu();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200519
520 __update_max_tr(tr, tsk, cpu);
Steven Rostedt92205c22008-05-12 21:20:55 +0200521 __raw_spin_unlock(&ftrace_max_lock);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200522}
523
524/**
525 * update_max_tr_single - only copy one trace over, and reset the rest
526 * @tr - tracer
527 * @tsk - task with the latency
528 * @cpu - the cpu of the buffer to copy.
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200529 *
530 * Flip the trace of a single CPU buffer between the @tr and the max_tr.
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200531 */
Ingo Molnare309b412008-05-12 21:20:51 +0200532void
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200533update_max_tr_single(struct trace_array *tr, struct task_struct *tsk, int cpu)
534{
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400535 int ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200536
Steven Rostedt4c11d7a2008-05-12 21:20:43 +0200537 WARN_ON_ONCE(!irqs_disabled());
Steven Rostedt92205c22008-05-12 21:20:55 +0200538 __raw_spin_lock(&ftrace_max_lock);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200539
Steven Rostedtd7690412008-10-01 00:29:53 -0400540 ftrace_disable_cpu();
541
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400542 ring_buffer_reset(max_tr.buffer);
543 ret = ring_buffer_swap_cpu(max_tr.buffer, tr->buffer, cpu);
544
Steven Rostedtd7690412008-10-01 00:29:53 -0400545 ftrace_enable_cpu();
546
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400547 WARN_ON_ONCE(ret);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200548
549 __update_max_tr(tr, tsk, cpu);
Steven Rostedt92205c22008-05-12 21:20:55 +0200550 __raw_spin_unlock(&ftrace_max_lock);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200551}
552
Steven Rostedt4fcdae82008-05-12 21:21:00 +0200553/**
554 * register_tracer - register a tracer with the ftrace system.
555 * @type - the plugin for the tracer
556 *
557 * Register a new plugin tracer.
558 */
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200559int register_tracer(struct tracer *type)
560{
561 struct tracer *t;
562 int len;
563 int ret = 0;
564
565 if (!type->name) {
566 pr_info("Tracer must have a name\n");
567 return -1;
568 }
569
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100570 /*
571 * When this gets called we hold the BKL which means that
572 * preemption is disabled. Various trace selftests however
573 * need to disable and enable preemption for successful tests.
574 * So we drop the BKL here and grab it after the tests again.
575 */
576 unlock_kernel();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200577 mutex_lock(&trace_types_lock);
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100578
Frederic Weisbecker8e1b82e2008-12-06 03:41:33 +0100579 tracing_selftest_running = true;
580
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200581 for (t = trace_types; t; t = t->next) {
582 if (strcmp(type->name, t->name) == 0) {
583 /* already found */
584 pr_info("Trace %s already registered\n",
585 type->name);
586 ret = -1;
587 goto out;
588 }
589 }
590
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +0100591 if (!type->set_flag)
592 type->set_flag = &dummy_set_flag;
593 if (!type->flags)
594 type->flags = &dummy_tracer_flags;
595 else
596 if (!type->flags->opts)
597 type->flags->opts = dummy_tracer_opt;
598
Steven Rostedt60a11772008-05-12 21:20:44 +0200599#ifdef CONFIG_FTRACE_STARTUP_TEST
600 if (type->selftest) {
601 struct tracer *saved_tracer = current_trace;
Steven Rostedt60a11772008-05-12 21:20:44 +0200602 struct trace_array *tr = &global_trace;
Steven Rostedt60a11772008-05-12 21:20:44 +0200603 int i;
Frederic Weisbeckerff325042008-12-04 23:47:35 +0100604
Steven Rostedt60a11772008-05-12 21:20:44 +0200605 /*
606 * Run a selftest on this tracer.
607 * Here we reset the trace buffer, and set the current
608 * tracer to be this tracer. The tracer can then run some
609 * internal tracing to verify that everything is in order.
610 * If we fail, we do not register this tracer.
611 */
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100612 for_each_tracing_cpu(i)
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400613 tracing_reset(tr, i);
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100614
Steven Rostedt60a11772008-05-12 21:20:44 +0200615 current_trace = type;
Steven Rostedt60a11772008-05-12 21:20:44 +0200616 /* the test is responsible for initializing and enabling */
617 pr_info("Testing tracer %s: ", type->name);
618 ret = type->selftest(type, tr);
619 /* the test is responsible for resetting too */
620 current_trace = saved_tracer;
Steven Rostedt60a11772008-05-12 21:20:44 +0200621 if (ret) {
622 printk(KERN_CONT "FAILED!\n");
623 goto out;
624 }
Steven Rostedt1d4db002008-05-12 21:20:45 +0200625 /* Only reset on passing, to avoid touching corrupted buffers */
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100626 for_each_tracing_cpu(i)
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400627 tracing_reset(tr, i);
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100628
Steven Rostedt60a11772008-05-12 21:20:44 +0200629 printk(KERN_CONT "PASSED\n");
630 }
631#endif
632
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200633 type->next = trace_types;
634 trace_types = type;
635 len = strlen(type->name);
636 if (len > max_tracer_type_len)
637 max_tracer_type_len = len;
Steven Rostedt60a11772008-05-12 21:20:44 +0200638
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200639 out:
Frederic Weisbecker8e1b82e2008-12-06 03:41:33 +0100640 tracing_selftest_running = false;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200641 mutex_unlock(&trace_types_lock);
Ingo Molnar86fa2f62008-11-19 10:00:15 +0100642 lock_kernel();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200643
644 return ret;
645}
646
647void unregister_tracer(struct tracer *type)
648{
649 struct tracer **t;
650 int len;
651
652 mutex_lock(&trace_types_lock);
653 for (t = &trace_types; *t; t = &(*t)->next) {
654 if (*t == type)
655 goto found;
656 }
657 pr_info("Trace %s not registered\n", type->name);
658 goto out;
659
660 found:
661 *t = (*t)->next;
662 if (strlen(type->name) != max_tracer_type_len)
663 goto out;
664
665 max_tracer_type_len = 0;
666 for (t = &trace_types; *t; t = &(*t)->next) {
667 len = strlen((*t)->name);
668 if (len > max_tracer_type_len)
669 max_tracer_type_len = len;
670 }
671 out:
672 mutex_unlock(&trace_types_lock);
673}
674
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400675void tracing_reset(struct trace_array *tr, int cpu)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200676{
Steven Rostedtd7690412008-10-01 00:29:53 -0400677 ftrace_disable_cpu();
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400678 ring_buffer_reset_cpu(tr->buffer, cpu);
Steven Rostedtd7690412008-10-01 00:29:53 -0400679 ftrace_enable_cpu();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200680}
681
Pekka J Enberg213cc062008-12-19 12:08:39 +0200682void tracing_reset_online_cpus(struct trace_array *tr)
683{
684 int cpu;
685
686 tr->time_start = ftrace_now(tr->cpu);
687
688 for_each_online_cpu(cpu)
689 tracing_reset(tr, cpu);
690}
691
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200692#define SAVED_CMDLINES 128
693static unsigned map_pid_to_cmdline[PID_MAX_DEFAULT+1];
694static unsigned map_cmdline_to_pid[SAVED_CMDLINES];
695static char saved_cmdlines[SAVED_CMDLINES][TASK_COMM_LEN];
696static int cmdline_idx;
697static DEFINE_SPINLOCK(trace_cmdline_lock);
Steven Rostedt25b0b442008-05-12 21:21:00 +0200698
Steven Rostedt25b0b442008-05-12 21:21:00 +0200699/* temporary disable recording */
700atomic_t trace_record_cmdline_disabled __read_mostly;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200701
702static void trace_init_cmdlines(void)
703{
704 memset(&map_pid_to_cmdline, -1, sizeof(map_pid_to_cmdline));
705 memset(&map_cmdline_to_pid, -1, sizeof(map_cmdline_to_pid));
706 cmdline_idx = 0;
707}
708
Steven Rostedt0f048702008-11-05 16:05:44 -0500709static int trace_stop_count;
710static DEFINE_SPINLOCK(tracing_start_lock);
711
712/**
Steven Rostedt69bb54e2008-11-21 12:59:38 -0500713 * ftrace_off_permanent - disable all ftrace code permanently
714 *
715 * This should only be called when a serious anomally has
716 * been detected. This will turn off the function tracing,
717 * ring buffers, and other tracing utilites. It takes no
718 * locks and can be called from any context.
719 */
720void ftrace_off_permanent(void)
721{
722 tracing_disabled = 1;
723 ftrace_stop();
724 tracing_off_permanent();
725}
726
727/**
Steven Rostedt0f048702008-11-05 16:05:44 -0500728 * tracing_start - quick start of the tracer
729 *
730 * If tracing is enabled but was stopped by tracing_stop,
731 * this will start the tracer back up.
732 */
733void tracing_start(void)
734{
735 struct ring_buffer *buffer;
736 unsigned long flags;
737
738 if (tracing_disabled)
739 return;
740
741 spin_lock_irqsave(&tracing_start_lock, flags);
742 if (--trace_stop_count)
743 goto out;
744
745 if (trace_stop_count < 0) {
746 /* Someone screwed up their debugging */
747 WARN_ON_ONCE(1);
748 trace_stop_count = 0;
749 goto out;
750 }
751
752
753 buffer = global_trace.buffer;
754 if (buffer)
755 ring_buffer_record_enable(buffer);
756
757 buffer = max_tr.buffer;
758 if (buffer)
759 ring_buffer_record_enable(buffer);
760
761 ftrace_start();
762 out:
763 spin_unlock_irqrestore(&tracing_start_lock, flags);
764}
765
766/**
767 * tracing_stop - quick stop of the tracer
768 *
769 * Light weight way to stop tracing. Use in conjunction with
770 * tracing_start.
771 */
772void tracing_stop(void)
773{
774 struct ring_buffer *buffer;
775 unsigned long flags;
776
777 ftrace_stop();
778 spin_lock_irqsave(&tracing_start_lock, flags);
779 if (trace_stop_count++)
780 goto out;
781
782 buffer = global_trace.buffer;
783 if (buffer)
784 ring_buffer_record_disable(buffer);
785
786 buffer = max_tr.buffer;
787 if (buffer)
788 ring_buffer_record_disable(buffer);
789
790 out:
791 spin_unlock_irqrestore(&tracing_start_lock, flags);
792}
793
Ingo Molnare309b412008-05-12 21:20:51 +0200794void trace_stop_cmdline_recording(void);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200795
Ingo Molnare309b412008-05-12 21:20:51 +0200796static void trace_save_cmdline(struct task_struct *tsk)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200797{
798 unsigned map;
799 unsigned idx;
800
801 if (!tsk->pid || unlikely(tsk->pid > PID_MAX_DEFAULT))
802 return;
803
804 /*
805 * It's not the end of the world if we don't get
806 * the lock, but we also don't want to spin
807 * nor do we want to disable interrupts,
808 * so if we miss here, then better luck next time.
809 */
810 if (!spin_trylock(&trace_cmdline_lock))
811 return;
812
813 idx = map_pid_to_cmdline[tsk->pid];
814 if (idx >= SAVED_CMDLINES) {
815 idx = (cmdline_idx + 1) % SAVED_CMDLINES;
816
817 map = map_cmdline_to_pid[idx];
818 if (map <= PID_MAX_DEFAULT)
819 map_pid_to_cmdline[map] = (unsigned)-1;
820
821 map_pid_to_cmdline[tsk->pid] = idx;
822
823 cmdline_idx = idx;
824 }
825
826 memcpy(&saved_cmdlines[idx], tsk->comm, TASK_COMM_LEN);
827
828 spin_unlock(&trace_cmdline_lock);
829}
830
Steven Rostedt660c7f92008-11-26 00:16:26 -0500831char *trace_find_cmdline(int pid)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200832{
833 char *cmdline = "<...>";
834 unsigned map;
835
836 if (!pid)
837 return "<idle>";
838
839 if (pid > PID_MAX_DEFAULT)
840 goto out;
841
842 map = map_pid_to_cmdline[pid];
843 if (map >= SAVED_CMDLINES)
844 goto out;
845
846 cmdline = saved_cmdlines[map];
847
848 out:
849 return cmdline;
850}
851
Ingo Molnare309b412008-05-12 21:20:51 +0200852void tracing_record_cmdline(struct task_struct *tsk)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200853{
854 if (atomic_read(&trace_record_cmdline_disabled))
855 return;
856
857 trace_save_cmdline(tsk);
858}
859
Pekka Paalanen45dcd8b2008-09-16 21:56:41 +0300860void
Steven Rostedt38697052008-10-01 13:14:09 -0400861tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags,
862 int pc)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200863{
864 struct task_struct *tsk = current;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200865
Steven Rostedt777e2082008-09-29 23:02:42 -0400866 entry->preempt_count = pc & 0xff;
867 entry->pid = (tsk) ? tsk->pid : 0;
Török Edwinb54d3de2008-11-22 13:28:48 +0200868 entry->tgid = (tsk) ? tsk->tgid : 0;
Steven Rostedt777e2082008-09-29 23:02:42 -0400869 entry->flags =
Steven Rostedt92444892008-10-24 09:42:59 -0400870#ifdef CONFIG_TRACE_IRQFLAGS_SUPPORT
Steven Rostedt2e2ca152008-08-01 12:26:40 -0400871 (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
Steven Rostedt92444892008-10-24 09:42:59 -0400872#else
873 TRACE_FLAG_IRQS_NOSUPPORT |
874#endif
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200875 ((pc & HARDIRQ_MASK) ? TRACE_FLAG_HARDIRQ : 0) |
876 ((pc & SOFTIRQ_MASK) ? TRACE_FLAG_SOFTIRQ : 0) |
877 (need_resched() ? TRACE_FLAG_NEED_RESCHED : 0);
878}
879
Ingo Molnare309b412008-05-12 21:20:51 +0200880void
Steven Rostedt6fb44b72008-05-12 21:20:49 +0200881trace_function(struct trace_array *tr, struct trace_array_cpu *data,
Steven Rostedt38697052008-10-01 13:14:09 -0400882 unsigned long ip, unsigned long parent_ip, unsigned long flags,
883 int pc)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200884{
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400885 struct ring_buffer_event *event;
Steven Rostedt777e2082008-09-29 23:02:42 -0400886 struct ftrace_entry *entry;
Ingo Molnardcb63082008-05-12 21:20:48 +0200887 unsigned long irq_flags;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200888
Steven Rostedtd7690412008-10-01 00:29:53 -0400889 /* If we are reading the ring buffer, don't trace */
890 if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
891 return;
892
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400893 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
894 &irq_flags);
895 if (!event)
896 return;
897 entry = ring_buffer_event_data(event);
Steven Rostedt38697052008-10-01 13:14:09 -0400898 tracing_generic_entry_update(&entry->ent, flags, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -0400899 entry->ent.type = TRACE_FN;
900 entry->ip = ip;
901 entry->parent_ip = parent_ip;
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400902 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +0200903}
904
Frederic Weisbeckerfb526072008-11-25 21:07:04 +0100905#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100906static void __trace_graph_entry(struct trace_array *tr,
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100907 struct trace_array_cpu *data,
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100908 struct ftrace_graph_ent *trace,
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100909 unsigned long flags,
910 int pc)
911{
912 struct ring_buffer_event *event;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100913 struct ftrace_graph_ent_entry *entry;
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100914 unsigned long irq_flags;
915
916 if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
917 return;
918
919 event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
920 &irq_flags);
921 if (!event)
922 return;
923 entry = ring_buffer_event_data(event);
924 tracing_generic_entry_update(&entry->ent, flags, pc);
Frederic Weisbecker287b6e62008-11-26 00:57:25 +0100925 entry->ent.type = TRACE_GRAPH_ENT;
926 entry->graph_ent = *trace;
927 ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
928}
929
930static void __trace_graph_return(struct trace_array *tr,
931 struct trace_array_cpu *data,
932 struct ftrace_graph_ret *trace,
933 unsigned long flags,
934 int pc)
935{
936 struct ring_buffer_event *event;
937 struct ftrace_graph_ret_entry *entry;
938 unsigned long irq_flags;
939
940 if (unlikely(local_read(&__get_cpu_var(ftrace_cpu_disabled))))
941 return;
942
943 event = ring_buffer_lock_reserve(global_trace.buffer, sizeof(*entry),
944 &irq_flags);
945 if (!event)
946 return;
947 entry = ring_buffer_event_data(event);
948 tracing_generic_entry_update(&entry->ent, flags, pc);
949 entry->ent.type = TRACE_GRAPH_RET;
950 entry->ret = *trace;
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +0100951 ring_buffer_unlock_commit(global_trace.buffer, event, irq_flags);
952}
953#endif
954
Ingo Molnare309b412008-05-12 21:20:51 +0200955void
Ingo Molnar2e0f5762008-05-12 21:20:49 +0200956ftrace(struct trace_array *tr, struct trace_array_cpu *data,
Steven Rostedt38697052008-10-01 13:14:09 -0400957 unsigned long ip, unsigned long parent_ip, unsigned long flags,
958 int pc)
Ingo Molnar2e0f5762008-05-12 21:20:49 +0200959{
960 if (likely(!atomic_read(&data->disabled)))
Steven Rostedt38697052008-10-01 13:14:09 -0400961 trace_function(tr, data, ip, parent_ip, flags, pc);
Ingo Molnar2e0f5762008-05-12 21:20:49 +0200962}
963
Steven Rostedt38697052008-10-01 13:14:09 -0400964static void ftrace_trace_stack(struct trace_array *tr,
965 struct trace_array_cpu *data,
966 unsigned long flags,
967 int skip, int pc)
Ingo Molnar86387f72008-05-12 21:20:51 +0200968{
Al Viroc2c80522008-10-31 19:50:41 +0000969#ifdef CONFIG_STACKTRACE
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400970 struct ring_buffer_event *event;
Steven Rostedt777e2082008-09-29 23:02:42 -0400971 struct stack_entry *entry;
Ingo Molnar86387f72008-05-12 21:20:51 +0200972 struct stack_trace trace;
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400973 unsigned long irq_flags;
Ingo Molnar86387f72008-05-12 21:20:51 +0200974
975 if (!(trace_flags & TRACE_ITER_STACKTRACE))
976 return;
977
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400978 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
979 &irq_flags);
980 if (!event)
981 return;
982 entry = ring_buffer_event_data(event);
Steven Rostedt38697052008-10-01 13:14:09 -0400983 tracing_generic_entry_update(&entry->ent, flags, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -0400984 entry->ent.type = TRACE_STACK;
Ingo Molnar86387f72008-05-12 21:20:51 +0200985
Steven Rostedt777e2082008-09-29 23:02:42 -0400986 memset(&entry->caller, 0, sizeof(entry->caller));
Ingo Molnar86387f72008-05-12 21:20:51 +0200987
988 trace.nr_entries = 0;
989 trace.max_entries = FTRACE_STACK_ENTRIES;
990 trace.skip = skip;
Steven Rostedt777e2082008-09-29 23:02:42 -0400991 trace.entries = entry->caller;
Ingo Molnar86387f72008-05-12 21:20:51 +0200992
993 save_stack_trace(&trace);
Steven Rostedt3928a8a2008-09-29 23:02:41 -0400994 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Al Viroc2c80522008-10-31 19:50:41 +0000995#endif
Ingo Molnarf0a920d2008-05-12 21:20:47 +0200996}
997
Steven Rostedt38697052008-10-01 13:14:09 -0400998void __trace_stack(struct trace_array *tr,
999 struct trace_array_cpu *data,
1000 unsigned long flags,
1001 int skip)
1002{
1003 ftrace_trace_stack(tr, data, flags, skip, preempt_count());
1004}
1005
Török Edwin02b67512008-11-22 13:28:47 +02001006static void ftrace_trace_userstack(struct trace_array *tr,
1007 struct trace_array_cpu *data,
1008 unsigned long flags, int pc)
1009{
Török Edwinc7425ac2008-11-28 11:17:56 +02001010#ifdef CONFIG_STACKTRACE
Török Edwin8d7c6a92008-11-23 12:39:06 +02001011 struct ring_buffer_event *event;
Török Edwin02b67512008-11-22 13:28:47 +02001012 struct userstack_entry *entry;
1013 struct stack_trace trace;
Török Edwin02b67512008-11-22 13:28:47 +02001014 unsigned long irq_flags;
1015
1016 if (!(trace_flags & TRACE_ITER_USERSTACKTRACE))
1017 return;
1018
1019 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
1020 &irq_flags);
1021 if (!event)
1022 return;
1023 entry = ring_buffer_event_data(event);
1024 tracing_generic_entry_update(&entry->ent, flags, pc);
1025 entry->ent.type = TRACE_USER_STACK;
1026
1027 memset(&entry->caller, 0, sizeof(entry->caller));
1028
1029 trace.nr_entries = 0;
1030 trace.max_entries = FTRACE_STACK_ENTRIES;
1031 trace.skip = 0;
1032 trace.entries = entry->caller;
1033
1034 save_stack_trace_user(&trace);
1035 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Török Edwinc7425ac2008-11-28 11:17:56 +02001036#endif
Török Edwin02b67512008-11-22 13:28:47 +02001037}
1038
1039void __trace_userstack(struct trace_array *tr,
1040 struct trace_array_cpu *data,
1041 unsigned long flags)
1042{
1043 ftrace_trace_userstack(tr, data, flags, preempt_count());
1044}
1045
Steven Rostedt38697052008-10-01 13:14:09 -04001046static void
1047ftrace_trace_special(void *__tr, void *__data,
1048 unsigned long arg1, unsigned long arg2, unsigned long arg3,
1049 int pc)
Ingo Molnara4feb832008-05-12 21:21:02 +02001050{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001051 struct ring_buffer_event *event;
Ingo Molnara4feb832008-05-12 21:21:02 +02001052 struct trace_array_cpu *data = __data;
1053 struct trace_array *tr = __tr;
Steven Rostedt777e2082008-09-29 23:02:42 -04001054 struct special_entry *entry;
Ingo Molnara4feb832008-05-12 21:21:02 +02001055 unsigned long irq_flags;
1056
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001057 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
1058 &irq_flags);
1059 if (!event)
1060 return;
1061 entry = ring_buffer_event_data(event);
Steven Rostedt38697052008-10-01 13:14:09 -04001062 tracing_generic_entry_update(&entry->ent, 0, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -04001063 entry->ent.type = TRACE_SPECIAL;
1064 entry->arg1 = arg1;
1065 entry->arg2 = arg2;
1066 entry->arg3 = arg3;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001067 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Steven Rostedt38697052008-10-01 13:14:09 -04001068 ftrace_trace_stack(tr, data, irq_flags, 4, pc);
Török Edwin02b67512008-11-22 13:28:47 +02001069 ftrace_trace_userstack(tr, data, irq_flags, pc);
Ingo Molnara4feb832008-05-12 21:21:02 +02001070
1071 trace_wake_up();
1072}
1073
1074void
Steven Rostedt38697052008-10-01 13:14:09 -04001075__trace_special(void *__tr, void *__data,
1076 unsigned long arg1, unsigned long arg2, unsigned long arg3)
1077{
1078 ftrace_trace_special(__tr, __data, arg1, arg2, arg3, preempt_count());
1079}
1080
1081void
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001082tracing_sched_switch_trace(struct trace_array *tr,
1083 struct trace_array_cpu *data,
Ingo Molnar86387f72008-05-12 21:20:51 +02001084 struct task_struct *prev,
1085 struct task_struct *next,
Steven Rostedt38697052008-10-01 13:14:09 -04001086 unsigned long flags, int pc)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001087{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001088 struct ring_buffer_event *event;
Steven Rostedt777e2082008-09-29 23:02:42 -04001089 struct ctx_switch_entry *entry;
Ingo Molnardcb63082008-05-12 21:20:48 +02001090 unsigned long irq_flags;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001091
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001092 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
1093 &irq_flags);
1094 if (!event)
1095 return;
1096 entry = ring_buffer_event_data(event);
Steven Rostedt38697052008-10-01 13:14:09 -04001097 tracing_generic_entry_update(&entry->ent, flags, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -04001098 entry->ent.type = TRACE_CTX;
1099 entry->prev_pid = prev->pid;
1100 entry->prev_prio = prev->prio;
1101 entry->prev_state = prev->state;
1102 entry->next_pid = next->pid;
1103 entry->next_prio = next->prio;
1104 entry->next_state = next->state;
1105 entry->next_cpu = task_cpu(next);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001106 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Steven Rostedt38697052008-10-01 13:14:09 -04001107 ftrace_trace_stack(tr, data, flags, 5, pc);
Török Edwin02b67512008-11-22 13:28:47 +02001108 ftrace_trace_userstack(tr, data, flags, pc);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001109}
1110
Ingo Molnar57422792008-05-12 21:20:51 +02001111void
1112tracing_sched_wakeup_trace(struct trace_array *tr,
1113 struct trace_array_cpu *data,
Ingo Molnar86387f72008-05-12 21:20:51 +02001114 struct task_struct *wakee,
1115 struct task_struct *curr,
Steven Rostedt38697052008-10-01 13:14:09 -04001116 unsigned long flags, int pc)
Ingo Molnar57422792008-05-12 21:20:51 +02001117{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001118 struct ring_buffer_event *event;
Steven Rostedt777e2082008-09-29 23:02:42 -04001119 struct ctx_switch_entry *entry;
Ingo Molnar57422792008-05-12 21:20:51 +02001120 unsigned long irq_flags;
1121
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001122 event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry),
1123 &irq_flags);
1124 if (!event)
1125 return;
1126 entry = ring_buffer_event_data(event);
Steven Rostedt38697052008-10-01 13:14:09 -04001127 tracing_generic_entry_update(&entry->ent, flags, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -04001128 entry->ent.type = TRACE_WAKE;
1129 entry->prev_pid = curr->pid;
1130 entry->prev_prio = curr->prio;
1131 entry->prev_state = curr->state;
1132 entry->next_pid = wakee->pid;
1133 entry->next_prio = wakee->prio;
1134 entry->next_state = wakee->state;
1135 entry->next_cpu = task_cpu(wakee);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001136 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Steven Rostedt38697052008-10-01 13:14:09 -04001137 ftrace_trace_stack(tr, data, flags, 6, pc);
Török Edwin02b67512008-11-22 13:28:47 +02001138 ftrace_trace_userstack(tr, data, flags, pc);
Ingo Molnar017730c2008-05-12 21:20:52 +02001139
1140 trace_wake_up();
Ingo Molnar57422792008-05-12 21:20:51 +02001141}
1142
Steven Rostedt4902f882008-05-22 00:22:18 -04001143void
1144ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3)
1145{
1146 struct trace_array *tr = &global_trace;
1147 struct trace_array_cpu *data;
Steven Rostedt5aa1ba62008-11-10 23:07:30 -05001148 unsigned long flags;
Steven Rostedt4902f882008-05-22 00:22:18 -04001149 int cpu;
Steven Rostedt38697052008-10-01 13:14:09 -04001150 int pc;
Steven Rostedt4902f882008-05-22 00:22:18 -04001151
Steven Rostedtc76f0692008-11-07 22:36:02 -05001152 if (tracing_disabled)
Steven Rostedt4902f882008-05-22 00:22:18 -04001153 return;
1154
Steven Rostedt38697052008-10-01 13:14:09 -04001155 pc = preempt_count();
Steven Rostedt5aa1ba62008-11-10 23:07:30 -05001156 local_irq_save(flags);
Steven Rostedt4902f882008-05-22 00:22:18 -04001157 cpu = raw_smp_processor_id();
1158 data = tr->data[cpu];
Steven Rostedt4902f882008-05-22 00:22:18 -04001159
Steven Rostedt5aa1ba62008-11-10 23:07:30 -05001160 if (likely(atomic_inc_return(&data->disabled) == 1))
Steven Rostedt38697052008-10-01 13:14:09 -04001161 ftrace_trace_special(tr, data, arg1, arg2, arg3, pc);
Steven Rostedt4902f882008-05-22 00:22:18 -04001162
Steven Rostedt5aa1ba62008-11-10 23:07:30 -05001163 atomic_dec(&data->disabled);
1164 local_irq_restore(flags);
Steven Rostedt4902f882008-05-22 00:22:18 -04001165}
1166
Steven Rostedt606576c2008-10-06 19:06:12 -04001167#ifdef CONFIG_FUNCTION_TRACER
Ingo Molnare309b412008-05-12 21:20:51 +02001168static void
Steven Rostedtb2a866f2008-11-03 23:15:57 -05001169function_trace_call_preempt_only(unsigned long ip, unsigned long parent_ip)
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001170{
1171 struct trace_array *tr = &global_trace;
1172 struct trace_array_cpu *data;
1173 unsigned long flags;
1174 long disabled;
Steven Rostedt38697052008-10-01 13:14:09 -04001175 int cpu, resched;
1176 int pc;
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001177
Steven Rostedt60bc0802008-07-10 20:58:16 -04001178 if (unlikely(!ftrace_function_enabled))
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001179 return;
1180
Steven Rostedt38697052008-10-01 13:14:09 -04001181 pc = preempt_count();
Steven Rostedt182e9f52008-11-03 23:15:56 -05001182 resched = ftrace_preempt_disable();
Steven Rostedt38697052008-10-01 13:14:09 -04001183 local_save_flags(flags);
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001184 cpu = raw_smp_processor_id();
1185 data = tr->data[cpu];
1186 disabled = atomic_inc_return(&data->disabled);
1187
1188 if (likely(disabled == 1))
Steven Rostedt38697052008-10-01 13:14:09 -04001189 trace_function(tr, data, ip, parent_ip, flags, pc);
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001190
1191 atomic_dec(&data->disabled);
Steven Rostedt182e9f52008-11-03 23:15:56 -05001192 ftrace_preempt_enable(resched);
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001193}
1194
Steven Rostedtb2a866f2008-11-03 23:15:57 -05001195static void
1196function_trace_call(unsigned long ip, unsigned long parent_ip)
1197{
1198 struct trace_array *tr = &global_trace;
1199 struct trace_array_cpu *data;
1200 unsigned long flags;
1201 long disabled;
1202 int cpu;
1203 int pc;
1204
1205 if (unlikely(!ftrace_function_enabled))
1206 return;
1207
1208 /*
1209 * Need to use raw, since this must be called before the
1210 * recursive protection is performed.
1211 */
Steven Rostedtd51ad7a2008-11-15 15:48:29 -05001212 local_irq_save(flags);
Steven Rostedtb2a866f2008-11-03 23:15:57 -05001213 cpu = raw_smp_processor_id();
1214 data = tr->data[cpu];
1215 disabled = atomic_inc_return(&data->disabled);
1216
1217 if (likely(disabled == 1)) {
1218 pc = preempt_count();
1219 trace_function(tr, data, ip, parent_ip, flags, pc);
1220 }
1221
1222 atomic_dec(&data->disabled);
Steven Rostedtd51ad7a2008-11-15 15:48:29 -05001223 local_irq_restore(flags);
Steven Rostedtb2a866f2008-11-03 23:15:57 -05001224}
1225
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01001226#ifdef CONFIG_FUNCTION_GRAPH_TRACER
Steven Rostedte49dc192008-12-02 23:50:05 -05001227int trace_graph_entry(struct ftrace_graph_ent *trace)
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001228{
1229 struct trace_array *tr = &global_trace;
1230 struct trace_array_cpu *data;
1231 unsigned long flags;
1232 long disabled;
1233 int cpu;
1234 int pc;
1235
Steven Rostedt804a6852008-12-03 15:36:59 -05001236 if (!ftrace_trace_task(current))
1237 return 0;
1238
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001239 if (!ftrace_graph_addr(trace->func))
1240 return 0;
1241
Steven Rostedta5e25882008-12-02 15:34:05 -05001242 local_irq_save(flags);
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001243 cpu = raw_smp_processor_id();
1244 data = tr->data[cpu];
1245 disabled = atomic_inc_return(&data->disabled);
1246 if (likely(disabled == 1)) {
1247 pc = preempt_count();
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01001248 __trace_graph_entry(tr, data, trace, flags, pc);
1249 }
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001250 /* Only do the atomic if it is not already set */
1251 if (!test_tsk_trace_graph(current))
1252 set_tsk_trace_graph(current);
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01001253 atomic_dec(&data->disabled);
Steven Rostedta5e25882008-12-02 15:34:05 -05001254 local_irq_restore(flags);
Steven Rostedte49dc192008-12-02 23:50:05 -05001255
1256 return 1;
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01001257}
1258
1259void trace_graph_return(struct ftrace_graph_ret *trace)
1260{
1261 struct trace_array *tr = &global_trace;
1262 struct trace_array_cpu *data;
1263 unsigned long flags;
1264 long disabled;
1265 int cpu;
1266 int pc;
1267
Steven Rostedta5e25882008-12-02 15:34:05 -05001268 local_irq_save(flags);
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01001269 cpu = raw_smp_processor_id();
1270 data = tr->data[cpu];
1271 disabled = atomic_inc_return(&data->disabled);
1272 if (likely(disabled == 1)) {
1273 pc = preempt_count();
1274 __trace_graph_return(tr, data, trace, flags, pc);
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001275 }
Steven Rostedtea4e2bc2008-12-03 15:36:57 -05001276 if (!trace->depth)
1277 clear_tsk_trace_graph(current);
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001278 atomic_dec(&data->disabled);
Steven Rostedta5e25882008-12-02 15:34:05 -05001279 local_irq_restore(flags);
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001280}
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01001281#endif /* CONFIG_FUNCTION_GRAPH_TRACER */
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001282
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001283static struct ftrace_ops trace_ops __read_mostly =
1284{
1285 .func = function_trace_call,
1286};
1287
Ingo Molnare309b412008-05-12 21:20:51 +02001288void tracing_start_function_trace(void)
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001289{
Steven Rostedt60bc0802008-07-10 20:58:16 -04001290 ftrace_function_enabled = 0;
Steven Rostedtb2a866f2008-11-03 23:15:57 -05001291
1292 if (trace_flags & TRACE_ITER_PREEMPTONLY)
1293 trace_ops.func = function_trace_call_preempt_only;
1294 else
1295 trace_ops.func = function_trace_call;
1296
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001297 register_ftrace_function(&trace_ops);
Steven Rostedt90369902008-11-05 16:05:44 -05001298 ftrace_function_enabled = 1;
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001299}
1300
Ingo Molnare309b412008-05-12 21:20:51 +02001301void tracing_stop_function_trace(void)
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001302{
Steven Rostedt60bc0802008-07-10 20:58:16 -04001303 ftrace_function_enabled = 0;
Ingo Molnar2e0f5762008-05-12 21:20:49 +02001304 unregister_ftrace_function(&trace_ops);
1305}
1306#endif
1307
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001308enum trace_file_type {
1309 TRACE_FILE_LAT_FMT = 1,
Steven Rostedt12ef7d42008-11-12 17:52:38 -05001310 TRACE_FILE_ANNOTATE = 2,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001311};
1312
Steven Rostedt5a90f572008-09-03 17:42:51 -04001313static void trace_iterator_increment(struct trace_iterator *iter, int cpu)
1314{
Steven Rostedtd7690412008-10-01 00:29:53 -04001315 /* Don't allow ftrace to trace into the ring buffers */
1316 ftrace_disable_cpu();
1317
Steven Rostedt5a90f572008-09-03 17:42:51 -04001318 iter->idx++;
Steven Rostedtd7690412008-10-01 00:29:53 -04001319 if (iter->buffer_iter[iter->cpu])
1320 ring_buffer_read(iter->buffer_iter[iter->cpu], NULL);
1321
1322 ftrace_enable_cpu();
Steven Rostedt5a90f572008-09-03 17:42:51 -04001323}
1324
Ingo Molnare309b412008-05-12 21:20:51 +02001325static struct trace_entry *
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001326peek_next_entry(struct trace_iterator *iter, int cpu, u64 *ts)
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001327{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001328 struct ring_buffer_event *event;
1329 struct ring_buffer_iter *buf_iter = iter->buffer_iter[cpu];
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001330
Steven Rostedtd7690412008-10-01 00:29:53 -04001331 /* Don't allow ftrace to trace into the ring buffers */
1332 ftrace_disable_cpu();
1333
1334 if (buf_iter)
1335 event = ring_buffer_iter_peek(buf_iter, ts);
1336 else
1337 event = ring_buffer_peek(iter->tr->buffer, cpu, ts);
1338
1339 ftrace_enable_cpu();
1340
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001341 return event ? ring_buffer_event_data(event) : NULL;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001342}
Steven Rostedtd7690412008-10-01 00:29:53 -04001343
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001344static struct trace_entry *
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001345__find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001346{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001347 struct ring_buffer *buffer = iter->tr->buffer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001348 struct trace_entry *ent, *next = NULL;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001349 u64 next_ts = 0, ts;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001350 int next_cpu = -1;
1351 int cpu;
1352
Steven Rostedtab464282008-05-12 21:21:00 +02001353 for_each_tracing_cpu(cpu) {
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001354
1355 if (ring_buffer_empty_cpu(buffer, cpu))
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001356 continue;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001357
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001358 ent = peek_next_entry(iter, cpu, &ts);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001359
Ingo Molnarcdd31cd2008-05-12 21:20:46 +02001360 /*
1361 * Pick the entry with the smallest timestamp:
1362 */
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001363 if (ent && (!next || ts < next_ts)) {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001364 next = ent;
1365 next_cpu = cpu;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001366 next_ts = ts;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001367 }
1368 }
1369
1370 if (ent_cpu)
1371 *ent_cpu = next_cpu;
1372
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001373 if (ent_ts)
1374 *ent_ts = next_ts;
1375
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001376 return next;
1377}
1378
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001379/* Find the next real entry, without updating the iterator itself */
1380static struct trace_entry *
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001381find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts)
Steven Rostedtb3806b42008-05-12 21:20:46 +02001382{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001383 return __find_next_entry(iter, ent_cpu, ent_ts);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001384}
Ingo Molnar8c523a92008-05-12 21:20:46 +02001385
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001386/* Find the next real entry, and increment the iterator to the next entry */
1387static void *find_next_entry_inc(struct trace_iterator *iter)
1388{
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001389 iter->ent = __find_next_entry(iter, &iter->cpu, &iter->ts);
Steven Rostedtb3806b42008-05-12 21:20:46 +02001390
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001391 if (iter->ent)
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001392 trace_iterator_increment(iter, iter->cpu);
1393
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001394 return iter->ent ? iter : NULL;
Steven Rostedtb3806b42008-05-12 21:20:46 +02001395}
1396
Ingo Molnare309b412008-05-12 21:20:51 +02001397static void trace_consume(struct trace_iterator *iter)
Steven Rostedtb3806b42008-05-12 21:20:46 +02001398{
Steven Rostedtd7690412008-10-01 00:29:53 -04001399 /* Don't allow ftrace to trace into the ring buffers */
1400 ftrace_disable_cpu();
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001401 ring_buffer_consume(iter->tr->buffer, iter->cpu, &iter->ts);
Steven Rostedtd7690412008-10-01 00:29:53 -04001402 ftrace_enable_cpu();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001403}
1404
Ingo Molnare309b412008-05-12 21:20:51 +02001405static void *s_next(struct seq_file *m, void *v, loff_t *pos)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001406{
1407 struct trace_iterator *iter = m->private;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001408 int i = (int)*pos;
Ingo Molnar4e3c3332008-05-12 21:20:45 +02001409 void *ent;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001410
1411 (*pos)++;
1412
1413 /* can't go backwards */
1414 if (iter->idx > i)
1415 return NULL;
1416
1417 if (iter->idx < 0)
1418 ent = find_next_entry_inc(iter);
1419 else
1420 ent = iter;
1421
1422 while (ent && iter->idx < i)
1423 ent = find_next_entry_inc(iter);
1424
1425 iter->pos = *pos;
1426
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001427 return ent;
1428}
1429
1430static void *s_start(struct seq_file *m, loff_t *pos)
1431{
1432 struct trace_iterator *iter = m->private;
1433 void *p = NULL;
1434 loff_t l = 0;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001435 int cpu;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001436
1437 mutex_lock(&trace_types_lock);
1438
Steven Rostedtd15f57f2008-05-12 21:20:56 +02001439 if (!current_trace || current_trace != iter->trace) {
1440 mutex_unlock(&trace_types_lock);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001441 return NULL;
Steven Rostedtd15f57f2008-05-12 21:20:56 +02001442 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001443
1444 atomic_inc(&trace_record_cmdline_disabled);
1445
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001446 if (*pos != iter->pos) {
1447 iter->ent = NULL;
1448 iter->cpu = 0;
1449 iter->idx = -1;
1450
Steven Rostedtd7690412008-10-01 00:29:53 -04001451 ftrace_disable_cpu();
1452
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001453 for_each_tracing_cpu(cpu) {
1454 ring_buffer_iter_reset(iter->buffer_iter[cpu]);
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02001455 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001456
Steven Rostedtd7690412008-10-01 00:29:53 -04001457 ftrace_enable_cpu();
1458
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001459 for (p = iter; p && l < *pos; p = s_next(m, p, &l))
1460 ;
1461
1462 } else {
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02001463 l = *pos - 1;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001464 p = s_next(m, p, &l);
1465 }
1466
1467 return p;
1468}
1469
1470static void s_stop(struct seq_file *m, void *p)
1471{
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001472 atomic_dec(&trace_record_cmdline_disabled);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001473 mutex_unlock(&trace_types_lock);
1474}
1475
Abhishek Sagar76094a22008-05-28 00:03:18 +05301476#ifdef CONFIG_KRETPROBES
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001477static inline const char *kretprobed(const char *name)
Abhishek Sagar76094a22008-05-28 00:03:18 +05301478{
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001479 static const char tramp_name[] = "kretprobe_trampoline";
1480 int size = sizeof(tramp_name);
1481
1482 if (strncmp(tramp_name, name, size) == 0)
1483 return "[unknown/kretprobe'd]";
1484 return name;
Abhishek Sagar76094a22008-05-28 00:03:18 +05301485}
1486#else
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001487static inline const char *kretprobed(const char *name)
Abhishek Sagar76094a22008-05-28 00:03:18 +05301488{
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001489 return name;
Abhishek Sagar76094a22008-05-28 00:03:18 +05301490}
1491#endif /* CONFIG_KRETPROBES */
1492
Steven Rostedtb3806b42008-05-12 21:20:46 +02001493static int
Steven Rostedt214023c2008-05-12 21:20:46 +02001494seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001495{
1496#ifdef CONFIG_KALLSYMS
1497 char str[KSYM_SYMBOL_LEN];
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001498 const char *name;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001499
1500 kallsyms_lookup(address, NULL, NULL, NULL, str);
1501
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001502 name = kretprobed(str);
1503
1504 return trace_seq_printf(s, fmt, name);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001505#endif
Steven Rostedtb3806b42008-05-12 21:20:46 +02001506 return 1;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001507}
1508
Steven Rostedtb3806b42008-05-12 21:20:46 +02001509static int
Steven Rostedt214023c2008-05-12 21:20:46 +02001510seq_print_sym_offset(struct trace_seq *s, const char *fmt,
1511 unsigned long address)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001512{
1513#ifdef CONFIG_KALLSYMS
1514 char str[KSYM_SYMBOL_LEN];
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001515 const char *name;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001516
1517 sprint_symbol(str, address);
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001518 name = kretprobed(str);
1519
1520 return trace_seq_printf(s, fmt, name);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001521#endif
Steven Rostedtb3806b42008-05-12 21:20:46 +02001522 return 1;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001523}
1524
1525#ifndef CONFIG_64BIT
1526# define IP_FMT "%08lx"
1527#else
1528# define IP_FMT "%016lx"
1529#endif
1530
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01001531int
Steven Rostedt214023c2008-05-12 21:20:46 +02001532seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001533{
Steven Rostedtb3806b42008-05-12 21:20:46 +02001534 int ret;
1535
1536 if (!ip)
1537 return trace_seq_printf(s, "0");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001538
1539 if (sym_flags & TRACE_ITER_SYM_OFFSET)
Steven Rostedtb3806b42008-05-12 21:20:46 +02001540 ret = seq_print_sym_offset(s, "%s", ip);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001541 else
Steven Rostedtb3806b42008-05-12 21:20:46 +02001542 ret = seq_print_sym_short(s, "%s", ip);
1543
1544 if (!ret)
1545 return 0;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001546
1547 if (sym_flags & TRACE_ITER_SYM_ADDR)
Steven Rostedtb3806b42008-05-12 21:20:46 +02001548 ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
1549 return ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001550}
1551
Török Edwinb54d3de2008-11-22 13:28:48 +02001552static inline int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
1553 unsigned long ip, unsigned long sym_flags)
1554{
1555 struct file *file = NULL;
1556 unsigned long vmstart = 0;
1557 int ret = 1;
1558
1559 if (mm) {
Török Edwincffa10a2008-11-23 12:39:07 +02001560 const struct vm_area_struct *vma;
1561
1562 down_read(&mm->mmap_sem);
1563 vma = find_vma(mm, ip);
Török Edwinb54d3de2008-11-22 13:28:48 +02001564 if (vma) {
1565 file = vma->vm_file;
1566 vmstart = vma->vm_start;
1567 }
Török Edwine38da592008-11-23 13:08:10 +02001568 if (file) {
1569 ret = trace_seq_path(s, &file->f_path);
1570 if (ret)
1571 ret = trace_seq_printf(s, "[+0x%lx]", ip - vmstart);
1572 }
Török Edwincffa10a2008-11-23 12:39:07 +02001573 up_read(&mm->mmap_sem);
Török Edwinb54d3de2008-11-22 13:28:48 +02001574 }
Török Edwinb54d3de2008-11-22 13:28:48 +02001575 if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
1576 ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
1577 return ret;
1578}
1579
Török Edwin02b67512008-11-22 13:28:47 +02001580static int
1581seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
Török Edwinb54d3de2008-11-22 13:28:48 +02001582 unsigned long sym_flags)
Török Edwin02b67512008-11-22 13:28:47 +02001583{
Török Edwinb54d3de2008-11-22 13:28:48 +02001584 struct mm_struct *mm = NULL;
Török Edwin02b67512008-11-22 13:28:47 +02001585 int ret = 1;
Török Edwin8d7c6a92008-11-23 12:39:06 +02001586 unsigned int i;
Török Edwin02b67512008-11-22 13:28:47 +02001587
Török Edwinb54d3de2008-11-22 13:28:48 +02001588 if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
1589 struct task_struct *task;
1590 /*
1591 * we do the lookup on the thread group leader,
1592 * since individual threads might have already quit!
1593 */
1594 rcu_read_lock();
1595 task = find_task_by_vpid(entry->ent.tgid);
Török Edwinb54d3de2008-11-22 13:28:48 +02001596 if (task)
1597 mm = get_task_mm(task);
Török Edwincffa10a2008-11-23 12:39:07 +02001598 rcu_read_unlock();
Török Edwinb54d3de2008-11-22 13:28:48 +02001599 }
1600
Török Edwin02b67512008-11-22 13:28:47 +02001601 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
1602 unsigned long ip = entry->caller[i];
1603
1604 if (ip == ULONG_MAX || !ret)
1605 break;
Török Edwinb54d3de2008-11-22 13:28:48 +02001606 if (i && ret)
Török Edwin02b67512008-11-22 13:28:47 +02001607 ret = trace_seq_puts(s, " <- ");
1608 if (!ip) {
Török Edwinb54d3de2008-11-22 13:28:48 +02001609 if (ret)
1610 ret = trace_seq_puts(s, "??");
Török Edwin02b67512008-11-22 13:28:47 +02001611 continue;
1612 }
Török Edwinb54d3de2008-11-22 13:28:48 +02001613 if (!ret)
1614 break;
1615 if (ret)
1616 ret = seq_print_user_ip(s, mm, ip, sym_flags);
Török Edwin02b67512008-11-22 13:28:47 +02001617 }
1618
Török Edwinb54d3de2008-11-22 13:28:48 +02001619 if (mm)
1620 mmput(mm);
Török Edwin02b67512008-11-22 13:28:47 +02001621 return ret;
1622}
1623
Ingo Molnare309b412008-05-12 21:20:51 +02001624static void print_lat_help_header(struct seq_file *m)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001625{
Michael Ellermana6168352008-08-20 16:36:11 -07001626 seq_puts(m, "# _------=> CPU# \n");
1627 seq_puts(m, "# / _-----=> irqs-off \n");
1628 seq_puts(m, "# | / _----=> need-resched \n");
1629 seq_puts(m, "# || / _---=> hardirq/softirq \n");
1630 seq_puts(m, "# ||| / _--=> preempt-depth \n");
1631 seq_puts(m, "# |||| / \n");
1632 seq_puts(m, "# ||||| delay \n");
1633 seq_puts(m, "# cmd pid ||||| time | caller \n");
1634 seq_puts(m, "# \\ / ||||| \\ | / \n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001635}
1636
Ingo Molnare309b412008-05-12 21:20:51 +02001637static void print_func_help_header(struct seq_file *m)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001638{
Michael Ellermana6168352008-08-20 16:36:11 -07001639 seq_puts(m, "# TASK-PID CPU# TIMESTAMP FUNCTION\n");
1640 seq_puts(m, "# | | | | |\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001641}
1642
1643
Ingo Molnare309b412008-05-12 21:20:51 +02001644static void
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001645print_trace_header(struct seq_file *m, struct trace_iterator *iter)
1646{
1647 unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
1648 struct trace_array *tr = iter->tr;
1649 struct trace_array_cpu *data = tr->data[tr->cpu];
1650 struct tracer *type = current_trace;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001651 unsigned long total;
1652 unsigned long entries;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001653 const char *name = "preemption";
1654
1655 if (type)
1656 name = type->name;
1657
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001658 entries = ring_buffer_entries(iter->tr->buffer);
1659 total = entries +
1660 ring_buffer_overruns(iter->tr->buffer);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001661
1662 seq_printf(m, "%s latency trace v1.1.5 on %s\n",
1663 name, UTS_RELEASE);
1664 seq_puts(m, "-----------------------------------"
1665 "---------------------------------\n");
1666 seq_printf(m, " latency: %lu us, #%lu/%lu, CPU#%d |"
1667 " (M:%s VP:%d, KP:%d, SP:%d HP:%d",
Steven Rostedt57f50be2008-05-12 21:20:44 +02001668 nsecs_to_usecs(data->saved_latency),
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001669 entries,
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02001670 total,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001671 tr->cpu,
1672#if defined(CONFIG_PREEMPT_NONE)
1673 "server",
1674#elif defined(CONFIG_PREEMPT_VOLUNTARY)
1675 "desktop",
Steven Rostedtb5c21b42008-07-10 20:58:12 -04001676#elif defined(CONFIG_PREEMPT)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001677 "preempt",
1678#else
1679 "unknown",
1680#endif
1681 /* These are reserved for later use */
1682 0, 0, 0, 0);
1683#ifdef CONFIG_SMP
1684 seq_printf(m, " #P:%d)\n", num_online_cpus());
1685#else
1686 seq_puts(m, ")\n");
1687#endif
1688 seq_puts(m, " -----------------\n");
1689 seq_printf(m, " | task: %.16s-%d "
1690 "(uid:%d nice:%ld policy:%ld rt_prio:%ld)\n",
1691 data->comm, data->pid, data->uid, data->nice,
1692 data->policy, data->rt_priority);
1693 seq_puts(m, " -----------------\n");
1694
1695 if (data->critical_start) {
1696 seq_puts(m, " => started at: ");
Steven Rostedt214023c2008-05-12 21:20:46 +02001697 seq_print_ip_sym(&iter->seq, data->critical_start, sym_flags);
1698 trace_print_seq(m, &iter->seq);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001699 seq_puts(m, "\n => ended at: ");
Steven Rostedt214023c2008-05-12 21:20:46 +02001700 seq_print_ip_sym(&iter->seq, data->critical_end, sym_flags);
1701 trace_print_seq(m, &iter->seq);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001702 seq_puts(m, "\n");
1703 }
1704
1705 seq_puts(m, "\n");
1706}
1707
Ingo Molnare309b412008-05-12 21:20:51 +02001708static void
Steven Rostedt214023c2008-05-12 21:20:46 +02001709lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001710{
1711 int hardirq, softirq;
1712 char *comm;
1713
Steven Rostedt777e2082008-09-29 23:02:42 -04001714 comm = trace_find_cmdline(entry->pid);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001715
Steven Rostedt777e2082008-09-29 23:02:42 -04001716 trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
Michael Ellermana6168352008-08-20 16:36:11 -07001717 trace_seq_printf(s, "%3d", cpu);
Steven Rostedt214023c2008-05-12 21:20:46 +02001718 trace_seq_printf(s, "%c%c",
Steven Rostedt92444892008-10-24 09:42:59 -04001719 (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
1720 (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.',
Steven Rostedt777e2082008-09-29 23:02:42 -04001721 ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.'));
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001722
Steven Rostedt777e2082008-09-29 23:02:42 -04001723 hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
1724 softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
Ingo Molnarafc2abc2008-05-12 21:21:00 +02001725 if (hardirq && softirq) {
Steven Rostedt214023c2008-05-12 21:20:46 +02001726 trace_seq_putc(s, 'H');
Ingo Molnarafc2abc2008-05-12 21:21:00 +02001727 } else {
1728 if (hardirq) {
Steven Rostedt214023c2008-05-12 21:20:46 +02001729 trace_seq_putc(s, 'h');
Ingo Molnarafc2abc2008-05-12 21:21:00 +02001730 } else {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001731 if (softirq)
Steven Rostedt214023c2008-05-12 21:20:46 +02001732 trace_seq_putc(s, 's');
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001733 else
Steven Rostedt214023c2008-05-12 21:20:46 +02001734 trace_seq_putc(s, '.');
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001735 }
1736 }
1737
Steven Rostedt777e2082008-09-29 23:02:42 -04001738 if (entry->preempt_count)
1739 trace_seq_printf(s, "%x", entry->preempt_count);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001740 else
Steven Rostedt214023c2008-05-12 21:20:46 +02001741 trace_seq_puts(s, ".");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001742}
1743
1744unsigned long preempt_mark_thresh = 100;
1745
Ingo Molnare309b412008-05-12 21:20:51 +02001746static void
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001747lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001748 unsigned long rel_usecs)
1749{
Steven Rostedt214023c2008-05-12 21:20:46 +02001750 trace_seq_printf(s, " %4lldus", abs_usecs);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001751 if (rel_usecs > preempt_mark_thresh)
Steven Rostedt214023c2008-05-12 21:20:46 +02001752 trace_seq_puts(s, "!: ");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001753 else if (rel_usecs > 1)
Steven Rostedt214023c2008-05-12 21:20:46 +02001754 trace_seq_puts(s, "+: ");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001755 else
Steven Rostedt214023c2008-05-12 21:20:46 +02001756 trace_seq_puts(s, " : ");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001757}
1758
1759static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
1760
Thomas Gleixner3d9101e2008-12-17 22:34:13 +01001761static int task_state_char(unsigned long state)
1762{
1763 int bit = state ? __ffs(state) + 1 : 0;
1764
1765 return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
1766}
1767
Steven Rostedta3097202008-11-07 22:36:02 -05001768static void test_cpu_buff_start(struct trace_iterator *iter)
1769{
1770 struct trace_seq *s = &iter->seq;
1771
Steven Rostedt12ef7d42008-11-12 17:52:38 -05001772 if (!(trace_flags & TRACE_ITER_ANNOTATE))
1773 return;
1774
1775 if (!(iter->iter_flags & TRACE_FILE_ANNOTATE))
1776 return;
1777
Steven Rostedta3097202008-11-07 22:36:02 -05001778 if (cpu_isset(iter->cpu, iter->started))
1779 return;
1780
1781 cpu_set(iter->cpu, iter->started);
1782 trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu);
1783}
1784
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001785static enum print_line_t
Steven Rostedt214023c2008-05-12 21:20:46 +02001786print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001787{
Steven Rostedt214023c2008-05-12 21:20:46 +02001788 struct trace_seq *s = &iter->seq;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001789 unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001790 struct trace_entry *next_entry;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001791 unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
1792 struct trace_entry *entry = iter->ent;
1793 unsigned long abs_usecs;
1794 unsigned long rel_usecs;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001795 u64 next_ts;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001796 char *comm;
Peter Zijlstrabac524d2008-05-12 21:20:53 +02001797 int S, T;
Ingo Molnar86387f72008-05-12 21:20:51 +02001798 int i;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001799
Steven Rostedta3097202008-11-07 22:36:02 -05001800 test_cpu_buff_start(iter);
1801
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001802 next_entry = find_next_entry(iter, NULL, &next_ts);
1803 if (!next_entry)
1804 next_ts = iter->ts;
1805 rel_usecs = ns2usecs(next_ts - iter->ts);
1806 abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001807
1808 if (verbose) {
Steven Rostedt777e2082008-09-29 23:02:42 -04001809 comm = trace_find_cmdline(entry->pid);
Michael Ellermana6168352008-08-20 16:36:11 -07001810 trace_seq_printf(s, "%16s %5d %3d %d %08x %08x [%08lx]"
Steven Rostedt214023c2008-05-12 21:20:46 +02001811 " %ld.%03ldms (+%ld.%03ldms): ",
1812 comm,
Steven Rostedt777e2082008-09-29 23:02:42 -04001813 entry->pid, cpu, entry->flags,
1814 entry->preempt_count, trace_idx,
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001815 ns2usecs(iter->ts),
Steven Rostedt214023c2008-05-12 21:20:46 +02001816 abs_usecs/1000,
1817 abs_usecs % 1000, rel_usecs/1000,
1818 rel_usecs % 1000);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001819 } else {
Ingo Molnarf29c73f2008-05-12 21:20:53 +02001820 lat_print_generic(s, entry, cpu);
1821 lat_print_timestamp(s, abs_usecs, rel_usecs);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001822 }
1823 switch (entry->type) {
Steven Rostedt777e2082008-09-29 23:02:42 -04001824 case TRACE_FN: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001825 struct ftrace_entry *field;
1826
1827 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001828
1829 seq_print_ip_sym(s, field->ip, sym_flags);
Steven Rostedt214023c2008-05-12 21:20:46 +02001830 trace_seq_puts(s, " (");
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001831 seq_print_ip_sym(s, field->parent_ip, sym_flags);
Steven Rostedt214023c2008-05-12 21:20:46 +02001832 trace_seq_puts(s, ")\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001833 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001834 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001835 case TRACE_CTX:
Steven Rostedt777e2082008-09-29 23:02:42 -04001836 case TRACE_WAKE: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001837 struct ctx_switch_entry *field;
1838
1839 trace_assign_type(field, entry);
Peter Zijlstrabac524d2008-05-12 21:20:53 +02001840
Thomas Gleixner3d9101e2008-12-17 22:34:13 +01001841 T = task_state_char(field->next_state);
1842 S = task_state_char(field->prev_state);
Steven Rostedt777e2082008-09-29 23:02:42 -04001843 comm = trace_find_cmdline(field->next_pid);
Peter Zijlstra80b5e942008-09-04 10:24:16 +02001844 trace_seq_printf(s, " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04001845 field->prev_pid,
1846 field->prev_prio,
Ingo Molnar57422792008-05-12 21:20:51 +02001847 S, entry->type == TRACE_CTX ? "==>" : " +",
Steven Rostedt777e2082008-09-29 23:02:42 -04001848 field->next_cpu,
1849 field->next_pid,
1850 field->next_prio,
Peter Zijlstrabac524d2008-05-12 21:20:53 +02001851 T, comm);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001852 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001853 }
1854 case TRACE_SPECIAL: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001855 struct special_entry *field;
1856
1857 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001858
Ingo Molnar88a42162008-05-12 21:20:53 +02001859 trace_seq_printf(s, "# %ld %ld %ld\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04001860 field->arg1,
1861 field->arg2,
1862 field->arg3);
Ingo Molnarf0a920d2008-05-12 21:20:47 +02001863 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001864 }
1865 case TRACE_STACK: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001866 struct stack_entry *field;
1867
1868 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001869
Ingo Molnar86387f72008-05-12 21:20:51 +02001870 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
1871 if (i)
1872 trace_seq_puts(s, " <= ");
Steven Rostedt777e2082008-09-29 23:02:42 -04001873 seq_print_ip_sym(s, field->caller[i], sym_flags);
Ingo Molnar86387f72008-05-12 21:20:51 +02001874 }
1875 trace_seq_puts(s, "\n");
1876 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001877 }
1878 case TRACE_PRINT: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001879 struct print_entry *field;
1880
1881 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001882
1883 seq_print_ip_sym(s, field->ip, sym_flags);
1884 trace_seq_printf(s, ": %s", field->buf);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001885 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001886 }
Steven Rostedt9f029e82008-11-12 15:24:24 -05001887 case TRACE_BRANCH: {
1888 struct trace_branch *field;
Steven Rostedt52f232c2008-11-12 00:14:40 -05001889
1890 trace_assign_type(field, entry);
1891
1892 trace_seq_printf(s, "[%s] %s:%s:%d\n",
Ingo Molnar68d119f2008-11-12 14:09:30 +01001893 field->correct ? " ok " : " MISS ",
Steven Rostedt52f232c2008-11-12 00:14:40 -05001894 field->func,
1895 field->file,
1896 field->line);
1897 break;
1898 }
Török Edwin02b67512008-11-22 13:28:47 +02001899 case TRACE_USER_STACK: {
1900 struct userstack_entry *field;
1901
1902 trace_assign_type(field, entry);
1903
1904 seq_print_userip_objs(field, s, sym_flags);
Török Edwinb54d3de2008-11-22 13:28:48 +02001905 trace_seq_putc(s, '\n');
Török Edwin02b67512008-11-22 13:28:47 +02001906 break;
1907 }
Steven Rostedt89b2f972008-05-12 21:20:44 +02001908 default:
Steven Rostedt214023c2008-05-12 21:20:46 +02001909 trace_seq_printf(s, "Unknown type %d\n", entry->type);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001910 }
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001911 return TRACE_TYPE_HANDLED;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001912}
1913
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001914static enum print_line_t print_trace_fmt(struct trace_iterator *iter)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001915{
Steven Rostedt214023c2008-05-12 21:20:46 +02001916 struct trace_seq *s = &iter->seq;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001917 unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
Ingo Molnar4e3c3332008-05-12 21:20:45 +02001918 struct trace_entry *entry;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001919 unsigned long usec_rem;
1920 unsigned long long t;
1921 unsigned long secs;
1922 char *comm;
Steven Rostedtb3806b42008-05-12 21:20:46 +02001923 int ret;
Peter Zijlstrabac524d2008-05-12 21:20:53 +02001924 int S, T;
Ingo Molnar86387f72008-05-12 21:20:51 +02001925 int i;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001926
Ingo Molnar4e3c3332008-05-12 21:20:45 +02001927 entry = iter->ent;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04001928
Steven Rostedta3097202008-11-07 22:36:02 -05001929 test_cpu_buff_start(iter);
1930
Steven Rostedt777e2082008-09-29 23:02:42 -04001931 comm = trace_find_cmdline(iter->ent->pid);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001932
Steven Rostedt3928a8a2008-09-29 23:02:41 -04001933 t = ns2usecs(iter->ts);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001934 usec_rem = do_div(t, 1000000ULL);
1935 secs = (unsigned long)t;
1936
Steven Rostedt777e2082008-09-29 23:02:42 -04001937 ret = trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid);
Ingo Molnarf29c73f2008-05-12 21:20:53 +02001938 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001939 return TRACE_TYPE_PARTIAL_LINE;
Michael Ellermana6168352008-08-20 16:36:11 -07001940 ret = trace_seq_printf(s, "[%03d] ", iter->cpu);
Ingo Molnarf29c73f2008-05-12 21:20:53 +02001941 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001942 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf29c73f2008-05-12 21:20:53 +02001943 ret = trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem);
1944 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001945 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001946
1947 switch (entry->type) {
Steven Rostedt777e2082008-09-29 23:02:42 -04001948 case TRACE_FN: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001949 struct ftrace_entry *field;
1950
1951 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001952
1953 ret = seq_print_ip_sym(s, field->ip, sym_flags);
Steven Rostedtb3806b42008-05-12 21:20:46 +02001954 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001955 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001956 if ((sym_flags & TRACE_ITER_PRINT_PARENT) &&
Steven Rostedt777e2082008-09-29 23:02:42 -04001957 field->parent_ip) {
Steven Rostedtb3806b42008-05-12 21:20:46 +02001958 ret = trace_seq_printf(s, " <-");
1959 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001960 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtb3aa5572008-10-31 15:44:07 -04001961 ret = seq_print_ip_sym(s,
1962 field->parent_ip,
1963 sym_flags);
Steven Rostedtb3806b42008-05-12 21:20:46 +02001964 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001965 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001966 }
Steven Rostedtb3806b42008-05-12 21:20:46 +02001967 ret = trace_seq_printf(s, "\n");
1968 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001969 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001970 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001971 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001972 case TRACE_CTX:
Steven Rostedt777e2082008-09-29 23:02:42 -04001973 case TRACE_WAKE: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001974 struct ctx_switch_entry *field;
1975
1976 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001977
Thomas Gleixner3d9101e2008-12-17 22:34:13 +01001978 T = task_state_char(field->next_state);
1979 S = task_state_char(field->prev_state);
Peter Zijlstra80b5e942008-09-04 10:24:16 +02001980 ret = trace_seq_printf(s, " %5d:%3d:%c %s [%03d] %5d:%3d:%c\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04001981 field->prev_pid,
1982 field->prev_prio,
Steven Rostedtb3806b42008-05-12 21:20:46 +02001983 S,
Ingo Molnar57422792008-05-12 21:20:51 +02001984 entry->type == TRACE_CTX ? "==>" : " +",
Steven Rostedt777e2082008-09-29 23:02:42 -04001985 field->next_cpu,
1986 field->next_pid,
1987 field->next_prio,
Peter Zijlstrabac524d2008-05-12 21:20:53 +02001988 T);
Steven Rostedtb3806b42008-05-12 21:20:46 +02001989 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02001990 return TRACE_TYPE_PARTIAL_LINE;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02001991 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04001992 }
1993 case TRACE_SPECIAL: {
Steven Rostedt7104f302008-10-01 10:52:51 -04001994 struct special_entry *field;
1995
1996 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04001997
Ingo Molnar88a42162008-05-12 21:20:53 +02001998 ret = trace_seq_printf(s, "# %ld %ld %ld\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04001999 field->arg1,
2000 field->arg2,
2001 field->arg3);
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002002 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002003 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002004 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002005 }
2006 case TRACE_STACK: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002007 struct stack_entry *field;
2008
2009 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002010
Ingo Molnar86387f72008-05-12 21:20:51 +02002011 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
2012 if (i) {
2013 ret = trace_seq_puts(s, " <= ");
2014 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002015 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnar86387f72008-05-12 21:20:51 +02002016 }
Steven Rostedt777e2082008-09-29 23:02:42 -04002017 ret = seq_print_ip_sym(s, field->caller[i],
Ingo Molnar86387f72008-05-12 21:20:51 +02002018 sym_flags);
2019 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002020 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnar86387f72008-05-12 21:20:51 +02002021 }
2022 ret = trace_seq_puts(s, "\n");
2023 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002024 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnar86387f72008-05-12 21:20:51 +02002025 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002026 }
2027 case TRACE_PRINT: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002028 struct print_entry *field;
2029
2030 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002031
2032 seq_print_ip_sym(s, field->ip, sym_flags);
2033 trace_seq_printf(s, ": %s", field->buf);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04002034 break;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002035 }
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01002036 case TRACE_GRAPH_RET: {
Frederic Weisbeckerfb526072008-11-25 21:07:04 +01002037 return print_graph_function(iter);
Frederic Weisbecker287b6e62008-11-26 00:57:25 +01002038 }
2039 case TRACE_GRAPH_ENT: {
2040 return print_graph_function(iter);
Frederic Weisbecker15e6cb32008-11-11 07:14:25 +01002041 }
Steven Rostedt9f029e82008-11-12 15:24:24 -05002042 case TRACE_BRANCH: {
2043 struct trace_branch *field;
Steven Rostedt52f232c2008-11-12 00:14:40 -05002044
2045 trace_assign_type(field, entry);
2046
2047 trace_seq_printf(s, "[%s] %s:%s:%d\n",
Ingo Molnar68d119f2008-11-12 14:09:30 +01002048 field->correct ? " ok " : " MISS ",
Steven Rostedt52f232c2008-11-12 00:14:40 -05002049 field->func,
2050 field->file,
2051 field->line);
2052 break;
2053 }
Török Edwin02b67512008-11-22 13:28:47 +02002054 case TRACE_USER_STACK: {
2055 struct userstack_entry *field;
2056
2057 trace_assign_type(field, entry);
2058
2059 ret = seq_print_userip_objs(field, s, sym_flags);
2060 if (!ret)
2061 return TRACE_TYPE_PARTIAL_LINE;
2062 ret = trace_seq_putc(s, '\n');
2063 if (!ret)
2064 return TRACE_TYPE_PARTIAL_LINE;
2065 break;
2066 }
Steven Rostedt777e2082008-09-29 23:02:42 -04002067 }
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002068 return TRACE_TYPE_HANDLED;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002069}
2070
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002071static enum print_line_t print_raw_fmt(struct trace_iterator *iter)
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002072{
2073 struct trace_seq *s = &iter->seq;
2074 struct trace_entry *entry;
2075 int ret;
Peter Zijlstrabac524d2008-05-12 21:20:53 +02002076 int S, T;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002077
2078 entry = iter->ent;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04002079
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002080 ret = trace_seq_printf(s, "%d %d %llu ",
Steven Rostedt777e2082008-09-29 23:02:42 -04002081 entry->pid, iter->cpu, iter->ts);
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002082 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002083 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002084
2085 switch (entry->type) {
Steven Rostedt777e2082008-09-29 23:02:42 -04002086 case TRACE_FN: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002087 struct ftrace_entry *field;
2088
2089 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002090
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002091 ret = trace_seq_printf(s, "%x %x\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04002092 field->ip,
2093 field->parent_ip);
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002094 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002095 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002096 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002097 }
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002098 case TRACE_CTX:
Steven Rostedt777e2082008-09-29 23:02:42 -04002099 case TRACE_WAKE: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002100 struct ctx_switch_entry *field;
2101
2102 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002103
Thomas Gleixner3d9101e2008-12-17 22:34:13 +01002104 T = task_state_char(field->next_state);
2105 S = entry->type == TRACE_WAKE ? '+' :
2106 task_state_char(field->prev_state);
Peter Zijlstra80b5e942008-09-04 10:24:16 +02002107 ret = trace_seq_printf(s, "%d %d %c %d %d %d %c\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04002108 field->prev_pid,
2109 field->prev_prio,
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002110 S,
Steven Rostedt777e2082008-09-29 23:02:42 -04002111 field->next_cpu,
2112 field->next_pid,
2113 field->next_prio,
Peter Zijlstrabac524d2008-05-12 21:20:53 +02002114 T);
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002115 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002116 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002117 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002118 }
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002119 case TRACE_SPECIAL:
Török Edwin02b67512008-11-22 13:28:47 +02002120 case TRACE_USER_STACK:
Steven Rostedt777e2082008-09-29 23:02:42 -04002121 case TRACE_STACK: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002122 struct special_entry *field;
2123
2124 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002125
Ingo Molnar88a42162008-05-12 21:20:53 +02002126 ret = trace_seq_printf(s, "# %ld %ld %ld\n",
Steven Rostedt777e2082008-09-29 23:02:42 -04002127 field->arg1,
2128 field->arg2,
2129 field->arg3);
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002130 if (!ret)
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002131 return TRACE_TYPE_PARTIAL_LINE;
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002132 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002133 }
2134 case TRACE_PRINT: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002135 struct print_entry *field;
2136
2137 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002138
2139 trace_seq_printf(s, "# %lx %s", field->ip, field->buf);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04002140 break;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002141 }
Steven Rostedt777e2082008-09-29 23:02:42 -04002142 }
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002143 return TRACE_TYPE_HANDLED;
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002144}
2145
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002146#define SEQ_PUT_FIELD_RET(s, x) \
2147do { \
2148 if (!trace_seq_putmem(s, &(x), sizeof(x))) \
2149 return 0; \
2150} while (0)
2151
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002152#define SEQ_PUT_HEX_FIELD_RET(s, x) \
2153do { \
Harvey Harrisonad0a3b62008-10-08 17:44:55 -07002154 BUILD_BUG_ON(sizeof(x) > MAX_MEMHEX_BYTES); \
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002155 if (!trace_seq_putmem_hex(s, &(x), sizeof(x))) \
2156 return 0; \
2157} while (0)
2158
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002159static enum print_line_t print_hex_fmt(struct trace_iterator *iter)
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002160{
2161 struct trace_seq *s = &iter->seq;
2162 unsigned char newline = '\n';
2163 struct trace_entry *entry;
Peter Zijlstrabac524d2008-05-12 21:20:53 +02002164 int S, T;
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002165
2166 entry = iter->ent;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04002167
Steven Rostedt777e2082008-09-29 23:02:42 -04002168 SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002169 SEQ_PUT_HEX_FIELD_RET(s, iter->cpu);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002170 SEQ_PUT_HEX_FIELD_RET(s, iter->ts);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002171
2172 switch (entry->type) {
Steven Rostedt777e2082008-09-29 23:02:42 -04002173 case TRACE_FN: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002174 struct ftrace_entry *field;
2175
2176 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002177
2178 SEQ_PUT_HEX_FIELD_RET(s, field->ip);
2179 SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002180 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002181 }
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002182 case TRACE_CTX:
Steven Rostedt777e2082008-09-29 23:02:42 -04002183 case TRACE_WAKE: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002184 struct ctx_switch_entry *field;
2185
2186 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002187
Thomas Gleixner3d9101e2008-12-17 22:34:13 +01002188 T = task_state_char(field->next_state);
2189 S = entry->type == TRACE_WAKE ? '+' :
2190 task_state_char(field->prev_state);
Steven Rostedt777e2082008-09-29 23:02:42 -04002191 SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
2192 SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002193 SEQ_PUT_HEX_FIELD_RET(s, S);
Steven Rostedt777e2082008-09-29 23:02:42 -04002194 SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
2195 SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
2196 SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
Peter Zijlstrabac524d2008-05-12 21:20:53 +02002197 SEQ_PUT_HEX_FIELD_RET(s, T);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002198 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002199 }
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002200 case TRACE_SPECIAL:
Török Edwin02b67512008-11-22 13:28:47 +02002201 case TRACE_USER_STACK:
Steven Rostedt777e2082008-09-29 23:02:42 -04002202 case TRACE_STACK: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002203 struct special_entry *field;
2204
2205 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002206
2207 SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
2208 SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
2209 SEQ_PUT_HEX_FIELD_RET(s, field->arg3);
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002210 break;
2211 }
Steven Rostedt777e2082008-09-29 23:02:42 -04002212 }
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002213 SEQ_PUT_FIELD_RET(s, newline);
2214
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002215 return TRACE_TYPE_HANDLED;
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002216}
2217
Frederic Weisbecker66896a82008-12-13 20:18:13 +01002218static enum print_line_t print_printk_msg_only(struct trace_iterator *iter)
2219{
2220 struct trace_seq *s = &iter->seq;
2221 struct trace_entry *entry = iter->ent;
2222 struct print_entry *field;
2223 int ret;
2224
2225 trace_assign_type(field, entry);
2226
2227 ret = trace_seq_printf(s, field->buf);
2228 if (!ret)
2229 return TRACE_TYPE_PARTIAL_LINE;
2230
Frederic Weisbecker66896a82008-12-13 20:18:13 +01002231 return TRACE_TYPE_HANDLED;
2232}
2233
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002234static enum print_line_t print_bin_fmt(struct trace_iterator *iter)
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002235{
2236 struct trace_seq *s = &iter->seq;
2237 struct trace_entry *entry;
2238
2239 entry = iter->ent;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04002240
Steven Rostedt777e2082008-09-29 23:02:42 -04002241 SEQ_PUT_FIELD_RET(s, entry->pid);
Eric Anholt072ba492008-10-26 15:26:57 -07002242 SEQ_PUT_FIELD_RET(s, entry->cpu);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002243 SEQ_PUT_FIELD_RET(s, iter->ts);
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002244
2245 switch (entry->type) {
Steven Rostedt777e2082008-09-29 23:02:42 -04002246 case TRACE_FN: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002247 struct ftrace_entry *field;
2248
2249 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002250
2251 SEQ_PUT_FIELD_RET(s, field->ip);
2252 SEQ_PUT_FIELD_RET(s, field->parent_ip);
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002253 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002254 }
2255 case TRACE_CTX: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002256 struct ctx_switch_entry *field;
2257
2258 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002259
2260 SEQ_PUT_FIELD_RET(s, field->prev_pid);
2261 SEQ_PUT_FIELD_RET(s, field->prev_prio);
2262 SEQ_PUT_FIELD_RET(s, field->prev_state);
2263 SEQ_PUT_FIELD_RET(s, field->next_pid);
2264 SEQ_PUT_FIELD_RET(s, field->next_prio);
2265 SEQ_PUT_FIELD_RET(s, field->next_state);
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002266 break;
Steven Rostedt777e2082008-09-29 23:02:42 -04002267 }
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002268 case TRACE_SPECIAL:
Török Edwin02b67512008-11-22 13:28:47 +02002269 case TRACE_USER_STACK:
Steven Rostedt777e2082008-09-29 23:02:42 -04002270 case TRACE_STACK: {
Steven Rostedt7104f302008-10-01 10:52:51 -04002271 struct special_entry *field;
2272
2273 trace_assign_type(field, entry);
Steven Rostedt777e2082008-09-29 23:02:42 -04002274
2275 SEQ_PUT_FIELD_RET(s, field->arg1);
2276 SEQ_PUT_FIELD_RET(s, field->arg2);
2277 SEQ_PUT_FIELD_RET(s, field->arg3);
Ingo Molnarf0a920d2008-05-12 21:20:47 +02002278 break;
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002279 }
Steven Rostedt777e2082008-09-29 23:02:42 -04002280 }
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002281 return 1;
2282}
2283
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002284static int trace_empty(struct trace_iterator *iter)
2285{
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002286 int cpu;
2287
Steven Rostedtab464282008-05-12 21:21:00 +02002288 for_each_tracing_cpu(cpu) {
Steven Rostedtd7690412008-10-01 00:29:53 -04002289 if (iter->buffer_iter[cpu]) {
2290 if (!ring_buffer_iter_empty(iter->buffer_iter[cpu]))
2291 return 0;
2292 } else {
2293 if (!ring_buffer_empty_cpu(iter->tr->buffer, cpu))
2294 return 0;
2295 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002296 }
Steven Rostedtd7690412008-10-01 00:29:53 -04002297
Frederic Weisbecker797d3712008-09-30 18:13:45 +02002298 return 1;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002299}
2300
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002301static enum print_line_t print_trace_line(struct trace_iterator *iter)
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002302{
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02002303 enum print_line_t ret;
2304
2305 if (iter->trace && iter->trace->print_line) {
2306 ret = iter->trace->print_line(iter);
2307 if (ret != TRACE_TYPE_UNHANDLED)
2308 return ret;
2309 }
Thomas Gleixner72829bc2008-05-23 21:37:28 +02002310
Frederic Weisbecker66896a82008-12-13 20:18:13 +01002311 if (iter->ent->type == TRACE_PRINT &&
2312 trace_flags & TRACE_ITER_PRINTK &&
2313 trace_flags & TRACE_ITER_PRINTK_MSGONLY)
2314 return print_printk_msg_only(iter);
2315
Ingo Molnarcb0f12a2008-05-12 21:20:47 +02002316 if (trace_flags & TRACE_ITER_BIN)
2317 return print_bin_fmt(iter);
2318
Ingo Molnar5e3ca0e2008-05-12 21:20:49 +02002319 if (trace_flags & TRACE_ITER_HEX)
2320 return print_hex_fmt(iter);
2321
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002322 if (trace_flags & TRACE_ITER_RAW)
2323 return print_raw_fmt(iter);
2324
2325 if (iter->iter_flags & TRACE_FILE_LAT_FMT)
2326 return print_lat_fmt(iter, iter->idx, iter->cpu);
2327
2328 return print_trace_fmt(iter);
2329}
2330
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002331static int s_show(struct seq_file *m, void *v)
2332{
2333 struct trace_iterator *iter = v;
2334
2335 if (iter->ent == NULL) {
2336 if (iter->tr) {
2337 seq_printf(m, "# tracer: %s\n", iter->trace->name);
2338 seq_puts(m, "#\n");
2339 }
Markus Metzger8bba1bf2008-11-25 09:12:31 +01002340 if (iter->trace && iter->trace->print_header)
2341 iter->trace->print_header(m);
2342 else if (iter->iter_flags & TRACE_FILE_LAT_FMT) {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002343 /* print nothing if the buffers are empty */
2344 if (trace_empty(iter))
2345 return 0;
2346 print_trace_header(m, iter);
2347 if (!(trace_flags & TRACE_ITER_VERBOSE))
2348 print_lat_help_header(m);
2349 } else {
2350 if (!(trace_flags & TRACE_ITER_VERBOSE))
2351 print_func_help_header(m);
2352 }
2353 } else {
Ingo Molnarf9896bf2008-05-12 21:20:47 +02002354 print_trace_line(iter);
Steven Rostedt214023c2008-05-12 21:20:46 +02002355 trace_print_seq(m, &iter->seq);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002356 }
2357
2358 return 0;
2359}
2360
2361static struct seq_operations tracer_seq_ops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02002362 .start = s_start,
2363 .next = s_next,
2364 .stop = s_stop,
2365 .show = s_show,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002366};
2367
Ingo Molnare309b412008-05-12 21:20:51 +02002368static struct trace_iterator *
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002369__tracing_open(struct inode *inode, struct file *file, int *ret)
2370{
2371 struct trace_iterator *iter;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002372 struct seq_file *m;
2373 int cpu;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002374
Steven Rostedt60a11772008-05-12 21:20:44 +02002375 if (tracing_disabled) {
2376 *ret = -ENODEV;
2377 return NULL;
2378 }
2379
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002380 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
2381 if (!iter) {
2382 *ret = -ENOMEM;
2383 goto out;
2384 }
2385
2386 mutex_lock(&trace_types_lock);
2387 if (current_trace && current_trace->print_max)
2388 iter->tr = &max_tr;
2389 else
2390 iter->tr = inode->i_private;
2391 iter->trace = current_trace;
2392 iter->pos = -1;
2393
Markus Metzger8bba1bf2008-11-25 09:12:31 +01002394 /* Notify the tracer early; before we stop tracing. */
2395 if (iter->trace && iter->trace->open)
Markus Metzgera93751c2008-12-11 13:53:26 +01002396 iter->trace->open(iter);
Markus Metzger8bba1bf2008-11-25 09:12:31 +01002397
Steven Rostedt12ef7d42008-11-12 17:52:38 -05002398 /* Annotate start of buffers if we had overruns */
2399 if (ring_buffer_overruns(iter->tr->buffer))
2400 iter->iter_flags |= TRACE_FILE_ANNOTATE;
2401
2402
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002403 for_each_tracing_cpu(cpu) {
Steven Rostedtd7690412008-10-01 00:29:53 -04002404
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002405 iter->buffer_iter[cpu] =
2406 ring_buffer_read_start(iter->tr->buffer, cpu);
Steven Rostedtd7690412008-10-01 00:29:53 -04002407
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002408 if (!iter->buffer_iter[cpu])
2409 goto fail_buffer;
2410 }
2411
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002412 /* TODO stop tracer */
2413 *ret = seq_open(file, &tracer_seq_ops);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002414 if (*ret)
2415 goto fail_buffer;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002416
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002417 m = file->private_data;
2418 m->private = iter;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002419
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002420 /* stop the trace while dumping */
Steven Rostedt90369902008-11-05 16:05:44 -05002421 tracing_stop();
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002422
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002423 mutex_unlock(&trace_types_lock);
2424
2425 out:
2426 return iter;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002427
2428 fail_buffer:
2429 for_each_tracing_cpu(cpu) {
2430 if (iter->buffer_iter[cpu])
2431 ring_buffer_read_finish(iter->buffer_iter[cpu]);
2432 }
2433 mutex_unlock(&trace_types_lock);
Julia Lawall0bb943c2008-11-14 19:05:31 +01002434 kfree(iter);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002435
2436 return ERR_PTR(-ENOMEM);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002437}
2438
2439int tracing_open_generic(struct inode *inode, struct file *filp)
2440{
Steven Rostedt60a11772008-05-12 21:20:44 +02002441 if (tracing_disabled)
2442 return -ENODEV;
2443
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002444 filp->private_data = inode->i_private;
2445 return 0;
2446}
2447
2448int tracing_release(struct inode *inode, struct file *file)
2449{
2450 struct seq_file *m = (struct seq_file *)file->private_data;
2451 struct trace_iterator *iter = m->private;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002452 int cpu;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002453
2454 mutex_lock(&trace_types_lock);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04002455 for_each_tracing_cpu(cpu) {
2456 if (iter->buffer_iter[cpu])
2457 ring_buffer_read_finish(iter->buffer_iter[cpu]);
2458 }
2459
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002460 if (iter->trace && iter->trace->close)
2461 iter->trace->close(iter);
2462
2463 /* reenable tracing if it was previously enabled */
Steven Rostedt90369902008-11-05 16:05:44 -05002464 tracing_start();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002465 mutex_unlock(&trace_types_lock);
2466
2467 seq_release(inode, file);
2468 kfree(iter);
2469 return 0;
2470}
2471
2472static int tracing_open(struct inode *inode, struct file *file)
2473{
2474 int ret;
2475
2476 __tracing_open(inode, file, &ret);
2477
2478 return ret;
2479}
2480
2481static int tracing_lt_open(struct inode *inode, struct file *file)
2482{
2483 struct trace_iterator *iter;
2484 int ret;
2485
2486 iter = __tracing_open(inode, file, &ret);
2487
2488 if (!ret)
2489 iter->iter_flags |= TRACE_FILE_LAT_FMT;
2490
2491 return ret;
2492}
2493
2494
Ingo Molnare309b412008-05-12 21:20:51 +02002495static void *
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002496t_next(struct seq_file *m, void *v, loff_t *pos)
2497{
2498 struct tracer *t = m->private;
2499
2500 (*pos)++;
2501
2502 if (t)
2503 t = t->next;
2504
2505 m->private = t;
2506
2507 return t;
2508}
2509
2510static void *t_start(struct seq_file *m, loff_t *pos)
2511{
2512 struct tracer *t = m->private;
2513 loff_t l = 0;
2514
2515 mutex_lock(&trace_types_lock);
2516 for (; t && l < *pos; t = t_next(m, t, &l))
2517 ;
2518
2519 return t;
2520}
2521
2522static void t_stop(struct seq_file *m, void *p)
2523{
2524 mutex_unlock(&trace_types_lock);
2525}
2526
2527static int t_show(struct seq_file *m, void *v)
2528{
2529 struct tracer *t = v;
2530
2531 if (!t)
2532 return 0;
2533
2534 seq_printf(m, "%s", t->name);
2535 if (t->next)
2536 seq_putc(m, ' ');
2537 else
2538 seq_putc(m, '\n');
2539
2540 return 0;
2541}
2542
2543static struct seq_operations show_traces_seq_ops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02002544 .start = t_start,
2545 .next = t_next,
2546 .stop = t_stop,
2547 .show = t_show,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002548};
2549
2550static int show_traces_open(struct inode *inode, struct file *file)
2551{
2552 int ret;
2553
Steven Rostedt60a11772008-05-12 21:20:44 +02002554 if (tracing_disabled)
2555 return -ENODEV;
2556
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002557 ret = seq_open(file, &show_traces_seq_ops);
2558 if (!ret) {
2559 struct seq_file *m = file->private_data;
2560 m->private = trace_types;
2561 }
2562
2563 return ret;
2564}
2565
2566static struct file_operations tracing_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02002567 .open = tracing_open,
2568 .read = seq_read,
2569 .llseek = seq_lseek,
2570 .release = tracing_release,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002571};
2572
2573static struct file_operations tracing_lt_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02002574 .open = tracing_lt_open,
2575 .read = seq_read,
2576 .llseek = seq_lseek,
2577 .release = tracing_release,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002578};
2579
2580static struct file_operations show_traces_fops = {
Ingo Molnarc7078de2008-05-12 21:20:52 +02002581 .open = show_traces_open,
2582 .read = seq_read,
2583 .release = seq_release,
2584};
2585
Ingo Molnar36dfe922008-05-12 21:20:52 +02002586/*
2587 * Only trace on a CPU if the bitmask is set:
2588 */
2589static cpumask_t tracing_cpumask = CPU_MASK_ALL;
2590
2591/*
2592 * When tracing/tracing_cpu_mask is modified then this holds
2593 * the new bitmask we are about to install:
2594 */
2595static cpumask_t tracing_cpumask_new;
2596
2597/*
2598 * The tracer itself will not take this lock, but still we want
2599 * to provide a consistent cpumask to user-space:
2600 */
2601static DEFINE_MUTEX(tracing_cpumask_update_lock);
2602
2603/*
2604 * Temporary storage for the character representation of the
2605 * CPU bitmask (and one more byte for the newline):
2606 */
2607static char mask_str[NR_CPUS + 1];
2608
Ingo Molnarc7078de2008-05-12 21:20:52 +02002609static ssize_t
2610tracing_cpumask_read(struct file *filp, char __user *ubuf,
2611 size_t count, loff_t *ppos)
2612{
Ingo Molnar36dfe922008-05-12 21:20:52 +02002613 int len;
Ingo Molnarc7078de2008-05-12 21:20:52 +02002614
2615 mutex_lock(&tracing_cpumask_update_lock);
Ingo Molnar36dfe922008-05-12 21:20:52 +02002616
2617 len = cpumask_scnprintf(mask_str, count, tracing_cpumask);
2618 if (count - len < 2) {
2619 count = -EINVAL;
2620 goto out_err;
2621 }
2622 len += sprintf(mask_str + len, "\n");
2623 count = simple_read_from_buffer(ubuf, count, ppos, mask_str, NR_CPUS+1);
2624
2625out_err:
Ingo Molnarc7078de2008-05-12 21:20:52 +02002626 mutex_unlock(&tracing_cpumask_update_lock);
2627
2628 return count;
2629}
2630
2631static ssize_t
2632tracing_cpumask_write(struct file *filp, const char __user *ubuf,
2633 size_t count, loff_t *ppos)
2634{
Ingo Molnar36dfe922008-05-12 21:20:52 +02002635 int err, cpu;
Ingo Molnarc7078de2008-05-12 21:20:52 +02002636
2637 mutex_lock(&tracing_cpumask_update_lock);
Ingo Molnar36dfe922008-05-12 21:20:52 +02002638 err = cpumask_parse_user(ubuf, count, tracing_cpumask_new);
2639 if (err)
2640 goto err_unlock;
2641
Steven Rostedta5e25882008-12-02 15:34:05 -05002642 local_irq_disable();
Steven Rostedt92205c22008-05-12 21:20:55 +02002643 __raw_spin_lock(&ftrace_max_lock);
Steven Rostedtab464282008-05-12 21:21:00 +02002644 for_each_tracing_cpu(cpu) {
Ingo Molnar36dfe922008-05-12 21:20:52 +02002645 /*
2646 * Increase/decrease the disabled counter if we are
2647 * about to flip a bit in the cpumask:
2648 */
2649 if (cpu_isset(cpu, tracing_cpumask) &&
2650 !cpu_isset(cpu, tracing_cpumask_new)) {
2651 atomic_inc(&global_trace.data[cpu]->disabled);
2652 }
2653 if (!cpu_isset(cpu, tracing_cpumask) &&
2654 cpu_isset(cpu, tracing_cpumask_new)) {
2655 atomic_dec(&global_trace.data[cpu]->disabled);
2656 }
2657 }
Steven Rostedt92205c22008-05-12 21:20:55 +02002658 __raw_spin_unlock(&ftrace_max_lock);
Steven Rostedta5e25882008-12-02 15:34:05 -05002659 local_irq_enable();
Ingo Molnar36dfe922008-05-12 21:20:52 +02002660
2661 tracing_cpumask = tracing_cpumask_new;
2662
Ingo Molnarc7078de2008-05-12 21:20:52 +02002663 mutex_unlock(&tracing_cpumask_update_lock);
2664
Ingo Molnarc7078de2008-05-12 21:20:52 +02002665 return count;
Ingo Molnar36dfe922008-05-12 21:20:52 +02002666
2667err_unlock:
2668 mutex_unlock(&tracing_cpumask_update_lock);
2669
2670 return err;
Ingo Molnarc7078de2008-05-12 21:20:52 +02002671}
2672
2673static struct file_operations tracing_cpumask_fops = {
2674 .open = tracing_open_generic,
2675 .read = tracing_cpumask_read,
2676 .write = tracing_cpumask_write,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002677};
2678
2679static ssize_t
Steven Rostedtee6bce52008-11-12 17:52:37 -05002680tracing_trace_options_read(struct file *filp, char __user *ubuf,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002681 size_t cnt, loff_t *ppos)
2682{
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002683 int i;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002684 char *buf;
2685 int r = 0;
2686 int len = 0;
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002687 u32 tracer_flags = current_trace->flags->val;
2688 struct tracer_opt *trace_opts = current_trace->flags->opts;
2689
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002690
2691 /* calulate max size */
2692 for (i = 0; trace_options[i]; i++) {
2693 len += strlen(trace_options[i]);
2694 len += 3; /* "no" and space */
2695 }
2696
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002697 /*
2698 * Increase the size with names of options specific
2699 * of the current tracer.
2700 */
2701 for (i = 0; trace_opts[i].name; i++) {
2702 len += strlen(trace_opts[i].name);
2703 len += 3; /* "no" and space */
2704 }
2705
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002706 /* +2 for \n and \0 */
2707 buf = kmalloc(len + 2, GFP_KERNEL);
2708 if (!buf)
2709 return -ENOMEM;
2710
2711 for (i = 0; trace_options[i]; i++) {
2712 if (trace_flags & (1 << i))
2713 r += sprintf(buf + r, "%s ", trace_options[i]);
2714 else
2715 r += sprintf(buf + r, "no%s ", trace_options[i]);
2716 }
2717
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002718 for (i = 0; trace_opts[i].name; i++) {
2719 if (tracer_flags & trace_opts[i].bit)
2720 r += sprintf(buf + r, "%s ",
2721 trace_opts[i].name);
2722 else
2723 r += sprintf(buf + r, "no%s ",
2724 trace_opts[i].name);
2725 }
2726
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002727 r += sprintf(buf + r, "\n");
2728 WARN_ON(r >= len + 2);
2729
Ingo Molnar36dfe922008-05-12 21:20:52 +02002730 r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002731
2732 kfree(buf);
2733
2734 return r;
2735}
2736
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002737/* Try to assign a tracer specific option */
2738static int set_tracer_option(struct tracer *trace, char *cmp, int neg)
2739{
2740 struct tracer_flags *trace_flags = trace->flags;
2741 struct tracer_opt *opts = NULL;
2742 int ret = 0, i = 0;
2743 int len;
2744
2745 for (i = 0; trace_flags->opts[i].name; i++) {
2746 opts = &trace_flags->opts[i];
2747 len = strlen(opts->name);
2748
2749 if (strncmp(cmp, opts->name, len) == 0) {
2750 ret = trace->set_flag(trace_flags->val,
2751 opts->bit, !neg);
2752 break;
2753 }
2754 }
2755 /* Not found */
2756 if (!trace_flags->opts[i].name)
2757 return -EINVAL;
2758
2759 /* Refused to handle */
2760 if (ret)
2761 return ret;
2762
2763 if (neg)
2764 trace_flags->val &= ~opts->bit;
2765 else
2766 trace_flags->val |= opts->bit;
2767
2768 return 0;
2769}
2770
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002771static ssize_t
Steven Rostedtee6bce52008-11-12 17:52:37 -05002772tracing_trace_options_write(struct file *filp, const char __user *ubuf,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002773 size_t cnt, loff_t *ppos)
2774{
2775 char buf[64];
2776 char *cmp = buf;
2777 int neg = 0;
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002778 int ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002779 int i;
2780
Steven Rostedtcffae432008-05-12 21:21:00 +02002781 if (cnt >= sizeof(buf))
2782 return -EINVAL;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002783
2784 if (copy_from_user(&buf, ubuf, cnt))
2785 return -EFAULT;
2786
2787 buf[cnt] = 0;
2788
2789 if (strncmp(buf, "no", 2) == 0) {
2790 neg = 1;
2791 cmp += 2;
2792 }
2793
2794 for (i = 0; trace_options[i]; i++) {
2795 int len = strlen(trace_options[i]);
2796
2797 if (strncmp(cmp, trace_options[i], len) == 0) {
2798 if (neg)
2799 trace_flags &= ~(1 << i);
2800 else
2801 trace_flags |= (1 << i);
2802 break;
2803 }
2804 }
Frederic Weisbeckeradf9f192008-11-17 19:23:42 +01002805
2806 /* If no option could be set, test the specific tracer options */
2807 if (!trace_options[i]) {
2808 ret = set_tracer_option(current_trace, cmp, neg);
2809 if (ret)
2810 return ret;
2811 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002812
2813 filp->f_pos += cnt;
2814
2815 return cnt;
2816}
2817
2818static struct file_operations tracing_iter_fops = {
Ingo Molnarc7078de2008-05-12 21:20:52 +02002819 .open = tracing_open_generic,
Steven Rostedtee6bce52008-11-12 17:52:37 -05002820 .read = tracing_trace_options_read,
2821 .write = tracing_trace_options_write,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002822};
2823
Ingo Molnar7bd2f242008-05-12 21:20:45 +02002824static const char readme_msg[] =
2825 "tracing mini-HOWTO:\n\n"
2826 "# mkdir /debug\n"
2827 "# mount -t debugfs nodev /debug\n\n"
2828 "# cat /debug/tracing/available_tracers\n"
2829 "wakeup preemptirqsoff preemptoff irqsoff ftrace sched_switch none\n\n"
2830 "# cat /debug/tracing/current_tracer\n"
2831 "none\n"
2832 "# echo sched_switch > /debug/tracing/current_tracer\n"
2833 "# cat /debug/tracing/current_tracer\n"
2834 "sched_switch\n"
Steven Rostedtee6bce52008-11-12 17:52:37 -05002835 "# cat /debug/tracing/trace_options\n"
Ingo Molnar7bd2f242008-05-12 21:20:45 +02002836 "noprint-parent nosym-offset nosym-addr noverbose\n"
Steven Rostedtee6bce52008-11-12 17:52:37 -05002837 "# echo print-parent > /debug/tracing/trace_options\n"
Ingo Molnar7bd2f242008-05-12 21:20:45 +02002838 "# echo 1 > /debug/tracing/tracing_enabled\n"
2839 "# cat /debug/tracing/trace > /tmp/trace.txt\n"
2840 "echo 0 > /debug/tracing/tracing_enabled\n"
2841;
2842
2843static ssize_t
2844tracing_readme_read(struct file *filp, char __user *ubuf,
2845 size_t cnt, loff_t *ppos)
2846{
2847 return simple_read_from_buffer(ubuf, cnt, ppos,
2848 readme_msg, strlen(readme_msg));
2849}
2850
2851static struct file_operations tracing_readme_fops = {
Ingo Molnarc7078de2008-05-12 21:20:52 +02002852 .open = tracing_open_generic,
2853 .read = tracing_readme_read,
Ingo Molnar7bd2f242008-05-12 21:20:45 +02002854};
2855
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002856static ssize_t
2857tracing_ctrl_read(struct file *filp, char __user *ubuf,
2858 size_t cnt, loff_t *ppos)
2859{
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002860 char buf[64];
2861 int r;
2862
Steven Rostedt90369902008-11-05 16:05:44 -05002863 r = sprintf(buf, "%u\n", tracer_enabled);
Ingo Molnar4e3c3332008-05-12 21:20:45 +02002864 return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002865}
2866
2867static ssize_t
2868tracing_ctrl_write(struct file *filp, const char __user *ubuf,
2869 size_t cnt, loff_t *ppos)
2870{
2871 struct trace_array *tr = filp->private_data;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002872 char buf[64];
Steven Rostedtc6caeeb2008-05-12 21:21:00 +02002873 long val;
2874 int ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002875
Steven Rostedtcffae432008-05-12 21:21:00 +02002876 if (cnt >= sizeof(buf))
2877 return -EINVAL;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002878
2879 if (copy_from_user(&buf, ubuf, cnt))
2880 return -EFAULT;
2881
2882 buf[cnt] = 0;
2883
Steven Rostedtc6caeeb2008-05-12 21:21:00 +02002884 ret = strict_strtoul(buf, 10, &val);
2885 if (ret < 0)
2886 return ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002887
2888 val = !!val;
2889
2890 mutex_lock(&trace_types_lock);
Steven Rostedt90369902008-11-05 16:05:44 -05002891 if (tracer_enabled ^ val) {
2892 if (val) {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002893 tracer_enabled = 1;
Steven Rostedt90369902008-11-05 16:05:44 -05002894 if (current_trace->start)
2895 current_trace->start(tr);
2896 tracing_start();
2897 } else {
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002898 tracer_enabled = 0;
Steven Rostedt90369902008-11-05 16:05:44 -05002899 tracing_stop();
2900 if (current_trace->stop)
2901 current_trace->stop(tr);
2902 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002903 }
2904 mutex_unlock(&trace_types_lock);
2905
2906 filp->f_pos += cnt;
2907
2908 return cnt;
2909}
2910
2911static ssize_t
2912tracing_set_trace_read(struct file *filp, char __user *ubuf,
2913 size_t cnt, loff_t *ppos)
2914{
2915 char buf[max_tracer_type_len+2];
2916 int r;
2917
2918 mutex_lock(&trace_types_lock);
2919 if (current_trace)
2920 r = sprintf(buf, "%s\n", current_trace->name);
2921 else
2922 r = sprintf(buf, "\n");
2923 mutex_unlock(&trace_types_lock);
2924
Ingo Molnar4bf39a92008-05-12 21:20:46 +02002925 return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002926}
2927
Peter Zijlstrad9e54072008-11-01 19:57:37 +01002928static int tracing_set_tracer(char *buf)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002929{
2930 struct trace_array *tr = &global_trace;
2931 struct tracer *t;
Peter Zijlstrad9e54072008-11-01 19:57:37 +01002932 int ret = 0;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002933
2934 mutex_lock(&trace_types_lock);
2935 for (t = trace_types; t; t = t->next) {
2936 if (strcmp(t->name, buf) == 0)
2937 break;
2938 }
Frederic Weisbeckerc2931e02008-10-04 22:04:44 +02002939 if (!t) {
2940 ret = -EINVAL;
2941 goto out;
2942 }
2943 if (t == current_trace)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002944 goto out;
2945
Steven Rostedt9f029e82008-11-12 15:24:24 -05002946 trace_branch_disable();
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002947 if (current_trace && current_trace->reset)
2948 current_trace->reset(tr);
2949
2950 current_trace = t;
Frederic Weisbecker1c800252008-11-16 05:57:26 +01002951 if (t->init) {
2952 ret = t->init(tr);
2953 if (ret)
2954 goto out;
2955 }
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002956
Steven Rostedt9f029e82008-11-12 15:24:24 -05002957 trace_branch_enable(tr);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002958 out:
2959 mutex_unlock(&trace_types_lock);
2960
Peter Zijlstrad9e54072008-11-01 19:57:37 +01002961 return ret;
2962}
2963
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002964static ssize_t
2965tracing_set_trace_write(struct file *filp, const char __user *ubuf,
2966 size_t cnt, loff_t *ppos)
2967{
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002968 char buf[max_tracer_type_len+1];
2969 int i;
2970 size_t ret;
Frederic Weisbeckere6e7a652008-11-16 05:53:19 +01002971 int err;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002972
Steven Rostedt60063a62008-10-28 10:44:24 -04002973 ret = cnt;
2974
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002975 if (cnt > max_tracer_type_len)
2976 cnt = max_tracer_type_len;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002977
2978 if (copy_from_user(&buf, ubuf, cnt))
2979 return -EFAULT;
2980
2981 buf[cnt] = 0;
2982
2983 /* strip ending whitespace. */
2984 for (i = cnt - 1; i > 0 && isspace(buf[i]); i--)
2985 buf[i] = 0;
2986
Frederic Weisbeckere6e7a652008-11-16 05:53:19 +01002987 err = tracing_set_tracer(buf);
2988 if (err)
2989 return err;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002990
Frederic Weisbeckere6e7a652008-11-16 05:53:19 +01002991 filp->f_pos += ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002992
Frederic Weisbeckerc2931e02008-10-04 22:04:44 +02002993 return ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02002994}
2995
2996static ssize_t
2997tracing_max_lat_read(struct file *filp, char __user *ubuf,
2998 size_t cnt, loff_t *ppos)
2999{
3000 unsigned long *ptr = filp->private_data;
3001 char buf[64];
3002 int r;
3003
Steven Rostedtcffae432008-05-12 21:21:00 +02003004 r = snprintf(buf, sizeof(buf), "%ld\n",
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003005 *ptr == (unsigned long)-1 ? -1 : nsecs_to_usecs(*ptr));
Steven Rostedtcffae432008-05-12 21:21:00 +02003006 if (r > sizeof(buf))
3007 r = sizeof(buf);
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003008 return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003009}
3010
3011static ssize_t
3012tracing_max_lat_write(struct file *filp, const char __user *ubuf,
3013 size_t cnt, loff_t *ppos)
3014{
3015 long *ptr = filp->private_data;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003016 char buf[64];
Steven Rostedtc6caeeb2008-05-12 21:21:00 +02003017 long val;
3018 int ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003019
Steven Rostedtcffae432008-05-12 21:21:00 +02003020 if (cnt >= sizeof(buf))
3021 return -EINVAL;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003022
3023 if (copy_from_user(&buf, ubuf, cnt))
3024 return -EFAULT;
3025
3026 buf[cnt] = 0;
3027
Steven Rostedtc6caeeb2008-05-12 21:21:00 +02003028 ret = strict_strtoul(buf, 10, &val);
3029 if (ret < 0)
3030 return ret;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003031
3032 *ptr = val * 1000;
3033
3034 return cnt;
3035}
3036
Steven Rostedtb3806b42008-05-12 21:20:46 +02003037static atomic_t tracing_reader;
3038
3039static int tracing_open_pipe(struct inode *inode, struct file *filp)
3040{
3041 struct trace_iterator *iter;
3042
3043 if (tracing_disabled)
3044 return -ENODEV;
3045
3046 /* We only allow for reader of the pipe */
3047 if (atomic_inc_return(&tracing_reader) != 1) {
3048 atomic_dec(&tracing_reader);
3049 return -EBUSY;
3050 }
3051
3052 /* create a buffer to store the information to pass to userspace */
3053 iter = kzalloc(sizeof(*iter), GFP_KERNEL);
3054 if (!iter)
3055 return -ENOMEM;
3056
Steven Rostedt107bad82008-05-12 21:21:01 +02003057 mutex_lock(&trace_types_lock);
Steven Rostedta3097202008-11-07 22:36:02 -05003058
3059 /* trace pipe does not show start of buffer */
3060 cpus_setall(iter->started);
3061
Steven Rostedtb3806b42008-05-12 21:20:46 +02003062 iter->tr = &global_trace;
Thomas Gleixner72829bc2008-05-23 21:37:28 +02003063 iter->trace = current_trace;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003064 filp->private_data = iter;
3065
Steven Rostedt107bad82008-05-12 21:21:01 +02003066 if (iter->trace->pipe_open)
3067 iter->trace->pipe_open(iter);
3068 mutex_unlock(&trace_types_lock);
3069
Steven Rostedtb3806b42008-05-12 21:20:46 +02003070 return 0;
3071}
3072
3073static int tracing_release_pipe(struct inode *inode, struct file *file)
3074{
3075 struct trace_iterator *iter = file->private_data;
3076
3077 kfree(iter);
3078 atomic_dec(&tracing_reader);
3079
3080 return 0;
3081}
3082
Soeren Sandmann Pedersen2a2cc8f2008-05-12 21:20:49 +02003083static unsigned int
3084tracing_poll_pipe(struct file *filp, poll_table *poll_table)
3085{
3086 struct trace_iterator *iter = filp->private_data;
3087
3088 if (trace_flags & TRACE_ITER_BLOCK) {
3089 /*
3090 * Always select as readable when in blocking mode
3091 */
3092 return POLLIN | POLLRDNORM;
Ingo Molnarafc2abc2008-05-12 21:21:00 +02003093 } else {
Soeren Sandmann Pedersen2a2cc8f2008-05-12 21:20:49 +02003094 if (!trace_empty(iter))
3095 return POLLIN | POLLRDNORM;
3096 poll_wait(filp, &trace_wait, poll_table);
3097 if (!trace_empty(iter))
3098 return POLLIN | POLLRDNORM;
3099
3100 return 0;
3101 }
3102}
3103
Steven Rostedtb3806b42008-05-12 21:20:46 +02003104/*
3105 * Consumer reader.
3106 */
3107static ssize_t
3108tracing_read_pipe(struct file *filp, char __user *ubuf,
3109 size_t cnt, loff_t *ppos)
3110{
3111 struct trace_iterator *iter = filp->private_data;
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003112 ssize_t sret;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003113
3114 /* return any leftover data */
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003115 sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
3116 if (sret != -EBUSY)
3117 return sret;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003118
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003119 trace_seq_reset(&iter->seq);
Steven Rostedtb3806b42008-05-12 21:20:46 +02003120
Steven Rostedt107bad82008-05-12 21:21:01 +02003121 mutex_lock(&trace_types_lock);
3122 if (iter->trace->read) {
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003123 sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);
3124 if (sret)
Steven Rostedt107bad82008-05-12 21:21:01 +02003125 goto out;
Steven Rostedt107bad82008-05-12 21:21:01 +02003126 }
3127
Pekka Paalanen9ff4b972008-09-29 20:23:48 +02003128waitagain:
3129 sret = 0;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003130 while (trace_empty(iter)) {
Steven Rostedt2dc8f092008-05-12 21:20:58 +02003131
Steven Rostedt107bad82008-05-12 21:21:01 +02003132 if ((filp->f_flags & O_NONBLOCK)) {
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003133 sret = -EAGAIN;
Steven Rostedt107bad82008-05-12 21:21:01 +02003134 goto out;
3135 }
Steven Rostedt2dc8f092008-05-12 21:20:58 +02003136
Steven Rostedtb3806b42008-05-12 21:20:46 +02003137 /*
3138 * This is a make-shift waitqueue. The reason we don't use
3139 * an actual wait queue is because:
3140 * 1) we only ever have one waiter
3141 * 2) the tracing, traces all functions, we don't want
3142 * the overhead of calling wake_up and friends
3143 * (and tracing them too)
3144 * Anyway, this is really very primitive wakeup.
3145 */
3146 set_current_state(TASK_INTERRUPTIBLE);
3147 iter->tr->waiter = current;
3148
Steven Rostedt107bad82008-05-12 21:21:01 +02003149 mutex_unlock(&trace_types_lock);
3150
Ingo Molnar9fe068e2008-05-12 21:21:02 +02003151 /* sleep for 100 msecs, and try again. */
3152 schedule_timeout(HZ/10);
Steven Rostedtb3806b42008-05-12 21:20:46 +02003153
Steven Rostedt107bad82008-05-12 21:21:01 +02003154 mutex_lock(&trace_types_lock);
3155
Steven Rostedtb3806b42008-05-12 21:20:46 +02003156 iter->tr->waiter = NULL;
3157
Steven Rostedt107bad82008-05-12 21:21:01 +02003158 if (signal_pending(current)) {
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003159 sret = -EINTR;
Steven Rostedt107bad82008-05-12 21:21:01 +02003160 goto out;
3161 }
Steven Rostedtb3806b42008-05-12 21:20:46 +02003162
Steven Rostedt84527992008-05-12 21:20:58 +02003163 if (iter->trace != current_trace)
Steven Rostedt107bad82008-05-12 21:21:01 +02003164 goto out;
Steven Rostedt84527992008-05-12 21:20:58 +02003165
Steven Rostedtb3806b42008-05-12 21:20:46 +02003166 /*
3167 * We block until we read something and tracing is disabled.
3168 * We still block if tracing is disabled, but we have never
3169 * read anything. This allows a user to cat this file, and
3170 * then enable tracing. But after we have read something,
3171 * we give an EOF when tracing is again disabled.
3172 *
3173 * iter->pos will be 0 if we haven't read anything.
3174 */
3175 if (!tracer_enabled && iter->pos)
3176 break;
3177
3178 continue;
3179 }
3180
3181 /* stop when tracing is finished */
3182 if (trace_empty(iter))
Steven Rostedt107bad82008-05-12 21:21:01 +02003183 goto out;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003184
3185 if (cnt >= PAGE_SIZE)
3186 cnt = PAGE_SIZE - 1;
3187
Steven Rostedt53d0aa72008-05-12 21:21:01 +02003188 /* reset all but tr, trace, and overruns */
Steven Rostedt53d0aa72008-05-12 21:21:01 +02003189 memset(&iter->seq, 0,
3190 sizeof(struct trace_iterator) -
3191 offsetof(struct trace_iterator, seq));
Steven Rostedt4823ed72008-05-12 21:21:01 +02003192 iter->pos = -1;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003193
Steven Rostedt088b1e422008-05-12 21:20:48 +02003194 while (find_next_entry_inc(iter) != NULL) {
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02003195 enum print_line_t ret;
Steven Rostedt088b1e422008-05-12 21:20:48 +02003196 int len = iter->seq.len;
3197
Ingo Molnarf9896bf2008-05-12 21:20:47 +02003198 ret = print_trace_line(iter);
Frederic Weisbecker2c4f0352008-09-29 20:18:34 +02003199 if (ret == TRACE_TYPE_PARTIAL_LINE) {
Steven Rostedt088b1e422008-05-12 21:20:48 +02003200 /* don't print partial lines */
3201 iter->seq.len = len;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003202 break;
Steven Rostedt088b1e422008-05-12 21:20:48 +02003203 }
Steven Rostedtb3806b42008-05-12 21:20:46 +02003204
3205 trace_consume(iter);
3206
3207 if (iter->seq.len >= cnt)
3208 break;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003209 }
3210
Steven Rostedtb3806b42008-05-12 21:20:46 +02003211 /* Now copy what we have to the user */
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003212 sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
3213 if (iter->seq.readpos >= iter->seq.len)
Steven Rostedtb3806b42008-05-12 21:20:46 +02003214 trace_seq_reset(&iter->seq);
Pekka Paalanen9ff4b972008-09-29 20:23:48 +02003215
3216 /*
3217 * If there was nothing to send to user, inspite of consuming trace
3218 * entries, go back to wait for more entries.
3219 */
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003220 if (sret == -EBUSY)
Pekka Paalanen9ff4b972008-09-29 20:23:48 +02003221 goto waitagain;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003222
Steven Rostedt107bad82008-05-12 21:21:01 +02003223out:
3224 mutex_unlock(&trace_types_lock);
3225
Pekka Paalanen6c6c2792008-05-12 21:21:02 +02003226 return sret;
Steven Rostedtb3806b42008-05-12 21:20:46 +02003227}
3228
Steven Rostedta98a3c32008-05-12 21:20:59 +02003229static ssize_t
3230tracing_entries_read(struct file *filp, char __user *ubuf,
3231 size_t cnt, loff_t *ppos)
3232{
3233 struct trace_array *tr = filp->private_data;
3234 char buf[64];
3235 int r;
3236
Steven Rostedt1696b2b2008-11-13 00:09:35 -05003237 r = sprintf(buf, "%lu\n", tr->entries >> 10);
Steven Rostedta98a3c32008-05-12 21:20:59 +02003238 return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
3239}
3240
3241static ssize_t
3242tracing_entries_write(struct file *filp, const char __user *ubuf,
3243 size_t cnt, loff_t *ppos)
3244{
3245 unsigned long val;
3246 char buf[64];
Steven Rostedtbf5e6512008-11-10 21:46:00 -05003247 int ret, cpu;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003248
Steven Rostedtcffae432008-05-12 21:21:00 +02003249 if (cnt >= sizeof(buf))
3250 return -EINVAL;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003251
3252 if (copy_from_user(&buf, ubuf, cnt))
3253 return -EFAULT;
3254
3255 buf[cnt] = 0;
3256
Steven Rostedtc6caeeb2008-05-12 21:21:00 +02003257 ret = strict_strtoul(buf, 10, &val);
3258 if (ret < 0)
3259 return ret;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003260
3261 /* must have at least 1 entry */
3262 if (!val)
3263 return -EINVAL;
3264
3265 mutex_lock(&trace_types_lock);
3266
Steven Rostedtc76f0692008-11-07 22:36:02 -05003267 tracing_stop();
Steven Rostedta98a3c32008-05-12 21:20:59 +02003268
Steven Rostedtbf5e6512008-11-10 21:46:00 -05003269 /* disable all cpu buffers */
3270 for_each_tracing_cpu(cpu) {
3271 if (global_trace.data[cpu])
3272 atomic_inc(&global_trace.data[cpu]->disabled);
3273 if (max_tr.data[cpu])
3274 atomic_inc(&max_tr.data[cpu]->disabled);
3275 }
3276
Steven Rostedt1696b2b2008-11-13 00:09:35 -05003277 /* value is in KB */
3278 val <<= 10;
3279
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003280 if (val != global_trace.entries) {
3281 ret = ring_buffer_resize(global_trace.buffer, val);
3282 if (ret < 0) {
3283 cnt = ret;
Steven Rostedt3eefae92008-05-12 21:21:04 +02003284 goto out;
3285 }
3286
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003287 ret = ring_buffer_resize(max_tr.buffer, val);
3288 if (ret < 0) {
3289 int r;
3290 cnt = ret;
3291 r = ring_buffer_resize(global_trace.buffer,
3292 global_trace.entries);
3293 if (r < 0) {
3294 /* AARGH! We are left with different
3295 * size max buffer!!!! */
3296 WARN_ON(1);
3297 tracing_disabled = 1;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003298 }
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003299 goto out;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003300 }
Steven Rostedt3eefae92008-05-12 21:21:04 +02003301
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003302 global_trace.entries = val;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003303 }
3304
3305 filp->f_pos += cnt;
3306
Steven Rostedt19384c02008-05-22 00:22:16 -04003307 /* If check pages failed, return ENOMEM */
3308 if (tracing_disabled)
3309 cnt = -ENOMEM;
Steven Rostedta98a3c32008-05-12 21:20:59 +02003310 out:
Steven Rostedtbf5e6512008-11-10 21:46:00 -05003311 for_each_tracing_cpu(cpu) {
3312 if (global_trace.data[cpu])
3313 atomic_dec(&global_trace.data[cpu]->disabled);
3314 if (max_tr.data[cpu])
3315 atomic_dec(&max_tr.data[cpu]->disabled);
3316 }
3317
Steven Rostedtc76f0692008-11-07 22:36:02 -05003318 tracing_start();
Steven Rostedta98a3c32008-05-12 21:20:59 +02003319 max_tr.entries = global_trace.entries;
3320 mutex_unlock(&trace_types_lock);
3321
3322 return cnt;
3323}
3324
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003325static int mark_printk(const char *fmt, ...)
3326{
3327 int ret;
3328 va_list args;
3329 va_start(args, fmt);
Frederic Weisbecker1fd8f2a2008-12-03 23:45:11 +01003330 ret = trace_vprintk(0, -1, fmt, args);
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003331 va_end(args);
3332 return ret;
3333}
3334
3335static ssize_t
3336tracing_mark_write(struct file *filp, const char __user *ubuf,
3337 size_t cnt, loff_t *fpos)
3338{
3339 char *buf;
3340 char *end;
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003341
Steven Rostedtc76f0692008-11-07 22:36:02 -05003342 if (tracing_disabled)
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003343 return -EINVAL;
3344
3345 if (cnt > TRACE_BUF_SIZE)
3346 cnt = TRACE_BUF_SIZE;
3347
3348 buf = kmalloc(cnt + 1, GFP_KERNEL);
3349 if (buf == NULL)
3350 return -ENOMEM;
3351
3352 if (copy_from_user(buf, ubuf, cnt)) {
3353 kfree(buf);
3354 return -EFAULT;
3355 }
3356
3357 /* Cut from the first nil or newline. */
3358 buf[cnt] = '\0';
3359 end = strchr(buf, '\n');
3360 if (end)
3361 *end = '\0';
3362
3363 cnt = mark_printk("%s\n", buf);
3364 kfree(buf);
3365 *fpos += cnt;
3366
3367 return cnt;
3368}
3369
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003370static struct file_operations tracing_max_lat_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003371 .open = tracing_open_generic,
3372 .read = tracing_max_lat_read,
3373 .write = tracing_max_lat_write,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003374};
3375
3376static struct file_operations tracing_ctrl_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003377 .open = tracing_open_generic,
3378 .read = tracing_ctrl_read,
3379 .write = tracing_ctrl_write,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003380};
3381
3382static struct file_operations set_tracer_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003383 .open = tracing_open_generic,
3384 .read = tracing_set_trace_read,
3385 .write = tracing_set_trace_write,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003386};
3387
Steven Rostedtb3806b42008-05-12 21:20:46 +02003388static struct file_operations tracing_pipe_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003389 .open = tracing_open_pipe,
Soeren Sandmann Pedersen2a2cc8f2008-05-12 21:20:49 +02003390 .poll = tracing_poll_pipe,
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003391 .read = tracing_read_pipe,
3392 .release = tracing_release_pipe,
Steven Rostedtb3806b42008-05-12 21:20:46 +02003393};
3394
Steven Rostedta98a3c32008-05-12 21:20:59 +02003395static struct file_operations tracing_entries_fops = {
3396 .open = tracing_open_generic,
3397 .read = tracing_entries_read,
3398 .write = tracing_entries_write,
3399};
3400
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003401static struct file_operations tracing_mark_fops = {
Frédéric Weisbecker43a15382008-09-21 20:16:30 +02003402 .open = tracing_open_generic,
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003403 .write = tracing_mark_write,
3404};
3405
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003406#ifdef CONFIG_DYNAMIC_FTRACE
3407
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003408int __weak ftrace_arch_read_dyn_info(char *buf, int size)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003409{
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003410 return 0;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003411}
3412
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003413static ssize_t
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003414tracing_read_dyn_info(struct file *filp, char __user *ubuf,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003415 size_t cnt, loff_t *ppos)
3416{
Steven Rostedta26a2a22008-10-31 00:03:22 -04003417 static char ftrace_dyn_info_buffer[1024];
3418 static DEFINE_MUTEX(dyn_info_mutex);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003419 unsigned long *p = filp->private_data;
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003420 char *buf = ftrace_dyn_info_buffer;
Steven Rostedta26a2a22008-10-31 00:03:22 -04003421 int size = ARRAY_SIZE(ftrace_dyn_info_buffer);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003422 int r;
3423
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003424 mutex_lock(&dyn_info_mutex);
3425 r = sprintf(buf, "%ld ", *p);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003426
Steven Rostedta26a2a22008-10-31 00:03:22 -04003427 r += ftrace_arch_read_dyn_info(buf+r, (size-1)-r);
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003428 buf[r++] = '\n';
3429
3430 r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
3431
3432 mutex_unlock(&dyn_info_mutex);
3433
3434 return r;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003435}
3436
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003437static struct file_operations tracing_dyn_info_fops = {
Ingo Molnar4bf39a92008-05-12 21:20:46 +02003438 .open = tracing_open_generic,
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003439 .read = tracing_read_dyn_info,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003440};
3441#endif
3442
3443static struct dentry *d_tracer;
3444
3445struct dentry *tracing_init_dentry(void)
3446{
3447 static int once;
3448
3449 if (d_tracer)
3450 return d_tracer;
3451
3452 d_tracer = debugfs_create_dir("tracing", NULL);
3453
3454 if (!d_tracer && !once) {
3455 once = 1;
3456 pr_warning("Could not create debugfs directory 'tracing'\n");
3457 return NULL;
3458 }
3459
3460 return d_tracer;
3461}
3462
Steven Rostedt60a11772008-05-12 21:20:44 +02003463#ifdef CONFIG_FTRACE_SELFTEST
3464/* Let selftest have access to static functions in this file */
3465#include "trace_selftest.c"
3466#endif
3467
Frédéric Weisbeckerb5ad3842008-09-23 11:34:32 +01003468static __init int tracer_init_debugfs(void)
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003469{
3470 struct dentry *d_tracer;
3471 struct dentry *entry;
3472
3473 d_tracer = tracing_init_dentry();
3474
3475 entry = debugfs_create_file("tracing_enabled", 0644, d_tracer,
3476 &global_trace, &tracing_ctrl_fops);
3477 if (!entry)
3478 pr_warning("Could not create debugfs 'tracing_enabled' entry\n");
3479
Steven Rostedtee6bce52008-11-12 17:52:37 -05003480 entry = debugfs_create_file("trace_options", 0644, d_tracer,
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003481 NULL, &tracing_iter_fops);
3482 if (!entry)
Steven Rostedtee6bce52008-11-12 17:52:37 -05003483 pr_warning("Could not create debugfs 'trace_options' entry\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003484
Ingo Molnarc7078de2008-05-12 21:20:52 +02003485 entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
3486 NULL, &tracing_cpumask_fops);
3487 if (!entry)
3488 pr_warning("Could not create debugfs 'tracing_cpumask' entry\n");
3489
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003490 entry = debugfs_create_file("latency_trace", 0444, d_tracer,
3491 &global_trace, &tracing_lt_fops);
3492 if (!entry)
3493 pr_warning("Could not create debugfs 'latency_trace' entry\n");
3494
3495 entry = debugfs_create_file("trace", 0444, d_tracer,
3496 &global_trace, &tracing_fops);
3497 if (!entry)
3498 pr_warning("Could not create debugfs 'trace' entry\n");
3499
3500 entry = debugfs_create_file("available_tracers", 0444, d_tracer,
3501 &global_trace, &show_traces_fops);
3502 if (!entry)
Frédéric Weisbecker98a983a2008-08-15 21:08:22 +02003503 pr_warning("Could not create debugfs 'available_tracers' entry\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003504
3505 entry = debugfs_create_file("current_tracer", 0444, d_tracer,
3506 &global_trace, &set_tracer_fops);
3507 if (!entry)
Frédéric Weisbecker98a983a2008-08-15 21:08:22 +02003508 pr_warning("Could not create debugfs 'current_tracer' entry\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003509
3510 entry = debugfs_create_file("tracing_max_latency", 0644, d_tracer,
3511 &tracing_max_latency,
3512 &tracing_max_lat_fops);
3513 if (!entry)
3514 pr_warning("Could not create debugfs "
3515 "'tracing_max_latency' entry\n");
3516
3517 entry = debugfs_create_file("tracing_thresh", 0644, d_tracer,
3518 &tracing_thresh, &tracing_max_lat_fops);
3519 if (!entry)
3520 pr_warning("Could not create debugfs "
Frédéric Weisbecker98a983a2008-08-15 21:08:22 +02003521 "'tracing_thresh' entry\n");
Ingo Molnar7bd2f242008-05-12 21:20:45 +02003522 entry = debugfs_create_file("README", 0644, d_tracer,
3523 NULL, &tracing_readme_fops);
3524 if (!entry)
3525 pr_warning("Could not create debugfs 'README' entry\n");
3526
Steven Rostedtb3806b42008-05-12 21:20:46 +02003527 entry = debugfs_create_file("trace_pipe", 0644, d_tracer,
3528 NULL, &tracing_pipe_fops);
3529 if (!entry)
3530 pr_warning("Could not create debugfs "
Frédéric Weisbecker98a983a2008-08-15 21:08:22 +02003531 "'trace_pipe' entry\n");
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003532
Steven Rostedta94c80e2008-11-12 17:52:36 -05003533 entry = debugfs_create_file("buffer_size_kb", 0644, d_tracer,
Steven Rostedta98a3c32008-05-12 21:20:59 +02003534 &global_trace, &tracing_entries_fops);
3535 if (!entry)
3536 pr_warning("Could not create debugfs "
Steven Rostedta94c80e2008-11-12 17:52:36 -05003537 "'buffer_size_kb' entry\n");
Steven Rostedta98a3c32008-05-12 21:20:59 +02003538
Pekka Paalanen5bf9a1e2008-09-16 22:06:42 +03003539 entry = debugfs_create_file("trace_marker", 0220, d_tracer,
3540 NULL, &tracing_mark_fops);
3541 if (!entry)
3542 pr_warning("Could not create debugfs "
3543 "'trace_marker' entry\n");
3544
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003545#ifdef CONFIG_DYNAMIC_FTRACE
3546 entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
3547 &ftrace_update_tot_cnt,
Steven Rostedtb807c3d2008-10-30 16:08:33 -04003548 &tracing_dyn_info_fops);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003549 if (!entry)
3550 pr_warning("Could not create debugfs "
3551 "'dyn_ftrace_total_info' entry\n");
3552#endif
Ingo Molnard618b3e2008-05-12 21:20:49 +02003553#ifdef CONFIG_SYSPROF_TRACER
3554 init_tracer_sysprof_debugfs(d_tracer);
3555#endif
Frédéric Weisbeckerb5ad3842008-09-23 11:34:32 +01003556 return 0;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003557}
3558
Frederic Weisbecker1fd8f2a2008-12-03 23:45:11 +01003559int trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args)
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003560{
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003561 static DEFINE_SPINLOCK(trace_buf_lock);
3562 static char trace_buf[TRACE_BUF_SIZE];
Peter Zijlstraf09ce572008-09-04 10:24:14 +02003563
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003564 struct ring_buffer_event *event;
Peter Zijlstraf09ce572008-09-04 10:24:14 +02003565 struct trace_array *tr = &global_trace;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003566 struct trace_array_cpu *data;
Steven Rostedt38697052008-10-01 13:14:09 -04003567 int cpu, len = 0, size, pc;
Ingo Molnare726f5f2008-12-08 16:55:53 +01003568 struct print_entry *entry;
3569 unsigned long irq_flags;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003570
Frederic Weisbecker8e1b82e2008-12-06 03:41:33 +01003571 if (tracing_disabled || tracing_selftest_running)
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003572 return 0;
3573
Steven Rostedt38697052008-10-01 13:14:09 -04003574 pc = preempt_count();
3575 preempt_disable_notrace();
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003576 cpu = raw_smp_processor_id();
3577 data = tr->data[cpu];
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003578
Steven Rostedt3ea2e6d2008-10-04 02:01:00 -04003579 if (unlikely(atomic_read(&data->disabled)))
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003580 goto out;
3581
Frederic Weisbecker380c4b12008-12-06 03:43:41 +01003582 pause_graph_tracing();
3583 spin_lock_irqsave(&trace_buf_lock, irq_flags);
Pekka Paalanen801fe402008-09-16 21:58:24 +03003584 len = vsnprintf(trace_buf, TRACE_BUF_SIZE, fmt, args);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003585
3586 len = min(len, TRACE_BUF_SIZE-1);
3587 trace_buf[len] = 0;
3588
Steven Rostedt777e2082008-09-29 23:02:42 -04003589 size = sizeof(*entry) + len + 1;
3590 event = ring_buffer_lock_reserve(tr->buffer, size, &irq_flags);
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003591 if (!event)
3592 goto out_unlock;
Steven Rostedt777e2082008-09-29 23:02:42 -04003593 entry = ring_buffer_event_data(event);
Ingo Molnare726f5f2008-12-08 16:55:53 +01003594 tracing_generic_entry_update(&entry->ent, irq_flags, pc);
Steven Rostedt777e2082008-09-29 23:02:42 -04003595 entry->ent.type = TRACE_PRINT;
3596 entry->ip = ip;
Frederic Weisbecker1fd8f2a2008-12-03 23:45:11 +01003597 entry->depth = depth;
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003598
Steven Rostedt777e2082008-09-29 23:02:42 -04003599 memcpy(&entry->buf, trace_buf, len);
3600 entry->buf[len] = 0;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003601 ring_buffer_unlock_commit(tr->buffer, event, irq_flags);
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003602
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003603 out_unlock:
Frederic Weisbecker380c4b12008-12-06 03:43:41 +01003604 spin_unlock_irqrestore(&trace_buf_lock, irq_flags);
3605 unpause_graph_tracing();
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003606 out:
Steven Rostedt38697052008-10-01 13:14:09 -04003607 preempt_enable_notrace();
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003608
3609 return len;
3610}
Pekka Paalanen801fe402008-09-16 21:58:24 +03003611EXPORT_SYMBOL_GPL(trace_vprintk);
3612
3613int __ftrace_printk(unsigned long ip, const char *fmt, ...)
3614{
3615 int ret;
3616 va_list ap;
3617
3618 if (!(trace_flags & TRACE_ITER_PRINTK))
3619 return 0;
3620
3621 va_start(ap, fmt);
Frederic Weisbecker21a8c462008-12-04 23:51:23 +01003622 ret = trace_vprintk(ip, task_curr_ret_stack(current), fmt, ap);
Pekka Paalanen801fe402008-09-16 21:58:24 +03003623 va_end(ap);
3624 return ret;
3625}
Steven Rostedtdd0e5452008-08-01 12:26:41 -04003626EXPORT_SYMBOL_GPL(__ftrace_printk);
3627
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003628static int trace_panic_handler(struct notifier_block *this,
3629 unsigned long event, void *unused)
3630{
Steven Rostedt944ac422008-10-23 19:26:08 -04003631 if (ftrace_dump_on_oops)
3632 ftrace_dump();
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003633 return NOTIFY_OK;
3634}
3635
3636static struct notifier_block trace_panic_notifier = {
3637 .notifier_call = trace_panic_handler,
3638 .next = NULL,
3639 .priority = 150 /* priority: INT_MAX >= x >= 0 */
3640};
3641
3642static int trace_die_handler(struct notifier_block *self,
3643 unsigned long val,
3644 void *data)
3645{
3646 switch (val) {
3647 case DIE_OOPS:
Steven Rostedt944ac422008-10-23 19:26:08 -04003648 if (ftrace_dump_on_oops)
3649 ftrace_dump();
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003650 break;
3651 default:
3652 break;
3653 }
3654 return NOTIFY_OK;
3655}
3656
3657static struct notifier_block trace_die_notifier = {
3658 .notifier_call = trace_die_handler,
3659 .priority = 200
3660};
3661
3662/*
3663 * printk is set to max of 1024, we really don't need it that big.
3664 * Nothing should be printing 1000 characters anyway.
3665 */
3666#define TRACE_MAX_PRINT 1000
3667
3668/*
3669 * Define here KERN_TRACE so that we have one place to modify
3670 * it if we decide to change what log level the ftrace dump
3671 * should be at.
3672 */
3673#define KERN_TRACE KERN_INFO
3674
3675static void
3676trace_printk_seq(struct trace_seq *s)
3677{
3678 /* Probably should print a warning here. */
3679 if (s->len >= 1000)
3680 s->len = 1000;
3681
3682 /* should be zero ended, but we are paranoid. */
3683 s->buffer[s->len] = 0;
3684
3685 printk(KERN_TRACE "%s", s->buffer);
3686
3687 trace_seq_reset(s);
3688}
3689
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003690void ftrace_dump(void)
3691{
3692 static DEFINE_SPINLOCK(ftrace_dump_lock);
3693 /* use static because iter can be a bit big for the stack */
3694 static struct trace_iterator iter;
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003695 static cpumask_t mask;
3696 static int dump_ran;
Steven Rostedtd7690412008-10-01 00:29:53 -04003697 unsigned long flags;
3698 int cnt = 0, cpu;
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003699
3700 /* only one dump */
3701 spin_lock_irqsave(&ftrace_dump_lock, flags);
3702 if (dump_ran)
3703 goto out;
3704
3705 dump_ran = 1;
3706
3707 /* No turning back! */
Steven Rostedt81adbdc2008-10-23 09:33:02 -04003708 ftrace_kill();
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003709
Steven Rostedtd7690412008-10-01 00:29:53 -04003710 for_each_tracing_cpu(cpu) {
3711 atomic_inc(&global_trace.data[cpu]->disabled);
3712 }
3713
Török Edwinb54d3de2008-11-22 13:28:48 +02003714 /* don't look at user memory in panic mode */
3715 trace_flags &= ~TRACE_ITER_SYM_USEROBJ;
3716
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003717 printk(KERN_TRACE "Dumping ftrace buffer:\n");
3718
3719 iter.tr = &global_trace;
3720 iter.trace = current_trace;
3721
3722 /*
3723 * We need to stop all tracing on all CPUS to read the
3724 * the next buffer. This is a bit expensive, but is
3725 * not done often. We fill all what we can read,
3726 * and then release the locks again.
3727 */
3728
3729 cpus_clear(mask);
3730
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003731 while (!trace_empty(&iter)) {
3732
3733 if (!cnt)
3734 printk(KERN_TRACE "---------------------------------\n");
3735
3736 cnt++;
3737
3738 /* reset all but tr, trace, and overruns */
3739 memset(&iter.seq, 0,
3740 sizeof(struct trace_iterator) -
3741 offsetof(struct trace_iterator, seq));
3742 iter.iter_flags |= TRACE_FILE_LAT_FMT;
3743 iter.pos = -1;
3744
3745 if (find_next_entry_inc(&iter) != NULL) {
3746 print_trace_line(&iter);
3747 trace_consume(&iter);
3748 }
3749
3750 trace_printk_seq(&iter.seq);
3751 }
3752
3753 if (!cnt)
3754 printk(KERN_TRACE " (ftrace buffer empty)\n");
3755 else
3756 printk(KERN_TRACE "---------------------------------\n");
3757
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003758 out:
3759 spin_unlock_irqrestore(&ftrace_dump_lock, flags);
3760}
3761
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003762__init static int tracer_alloc_buffers(void)
3763{
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02003764 struct trace_array_cpu *data;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003765 int i;
3766
Steven Rostedtab464282008-05-12 21:21:00 +02003767 /* TODO: make the number of buffers hot pluggable with CPUS */
Steven Rostedtab464282008-05-12 21:21:00 +02003768 tracing_buffer_mask = cpu_possible_map;
3769
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003770 global_trace.buffer = ring_buffer_alloc(trace_buf_size,
3771 TRACE_BUFFER_FLAGS);
3772 if (!global_trace.buffer) {
3773 printk(KERN_ERR "tracer: failed to allocate ring buffer!\n");
3774 WARN_ON(1);
3775 return 0;
3776 }
3777 global_trace.entries = ring_buffer_size(global_trace.buffer);
3778
3779#ifdef CONFIG_TRACER_MAX_TRACE
3780 max_tr.buffer = ring_buffer_alloc(trace_buf_size,
3781 TRACE_BUFFER_FLAGS);
3782 if (!max_tr.buffer) {
3783 printk(KERN_ERR "tracer: failed to allocate max ring buffer!\n");
3784 WARN_ON(1);
3785 ring_buffer_free(global_trace.buffer);
3786 return 0;
3787 }
3788 max_tr.entries = ring_buffer_size(max_tr.buffer);
3789 WARN_ON(max_tr.entries != global_trace.entries);
3790#endif
3791
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02003792 /* Allocate the first page for all buffers */
Steven Rostedtab464282008-05-12 21:21:00 +02003793 for_each_tracing_cpu(i) {
Steven Rostedt4c11d7a2008-05-12 21:20:43 +02003794 data = global_trace.data[i] = &per_cpu(global_trace_cpu, i);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003795 max_tr.data[i] = &per_cpu(max_data, i);
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003796 }
3797
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003798 trace_init_cmdlines();
3799
Frédéric Weisbecker43a15382008-09-21 20:16:30 +02003800 register_tracer(&nop_trace);
Frédéric Weisbeckerb5ad3842008-09-23 11:34:32 +01003801#ifdef CONFIG_BOOT_TRACER
3802 register_tracer(&boot_tracer);
3803 current_trace = &boot_tracer;
3804 current_trace->init(&global_trace);
3805#else
Frédéric Weisbecker43a15382008-09-21 20:16:30 +02003806 current_trace = &nop_trace;
Frédéric Weisbeckerb5ad3842008-09-23 11:34:32 +01003807#endif
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003808
Steven Rostedt60a11772008-05-12 21:20:44 +02003809 /* All seems OK, enable tracing */
3810 tracing_disabled = 0;
Steven Rostedt3928a8a2008-09-29 23:02:41 -04003811
Steven Rostedt3f5a54e2008-07-30 22:36:46 -04003812 atomic_notifier_chain_register(&panic_notifier_list,
3813 &trace_panic_notifier);
3814
3815 register_die_notifier(&trace_die_notifier);
3816
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003817 return 0;
Steven Rostedtbc0c38d2008-05-12 21:20:42 +02003818}
Frédéric Weisbeckerb5ad3842008-09-23 11:34:32 +01003819early_initcall(tracer_alloc_buffers);
3820fs_initcall(tracer_init_debugfs);