/* * ring buffer based function tracer * * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com> * Copyright (C) 2008 Ingo Molnar <mingo@redhat.com> * * Originally taken from the RT patch by: *    Arnaldo Carvalho de Melo <acme@redhat.com> * * Based on code from the latency_tracer, that is: *  Copyright (C) 2004-2006 Ingo Molnar *  Copyright (C) 2004 William Lee Irwin III */#include <linux/ring_buffer.h>#include <generated/utsrelease.h>#include <linux/stacktrace.h>#include <linux/writeback.h>#include <linux/kallsyms.h>#include <linux/seq_file.h>#include <linux/notifier.h>#include <linux/irqflags.h>#include <linux/debugfs.h>#include <linux/pagemap.h>#include <linux/hardirq.h>#include <linux/linkage.h>#include <linux/uaccess.h>#include <linux/kprobes.h>#include <linux/ftrace.h>#include <linux/module.h>#include <linux/percpu.h>#include <linux/splice.h>#include <linux/kdebug.h>#include <linux/string.h>#include <linux/rwsem.h>#include <linux/slab.h>#include <linux/ctype.h>#include <linux/init.h>#include <linux/poll.h>#include <linux/nmi.h>#include <linux/fs.h> #include "trace.h"#include "trace_output.h" /* * On boot up, the ring buffer is set to the minimum size, so that * we do not waste memory on systems that are not using tracing. */int ring_buffer_expanded; /* * We need to change this state when a selftest is running. * A selftest will lurk into the ring-buffer to count the * entries inserted during the selftest although some concurrent * insertions into the ring-buffer such as trace_printk could occurred * at the same time, giving false positive or negative results. */static bool __read_mostly tracing_selftest_running; /* * If a tracer is running, we do not want to run SELFTEST. */bool __read_mostly tracing_selftest_disabled; /* For tracers that don't implement custom flags */static struct tracer_opt dummy_tracer_opt[] = {	{ }}; static struct tracer_flags dummy_tracer_flags = {	.val = 0,	.opts = dummy_tracer_opt}; static int dummy_set_flag(u32 old_flags, u32 bit, int set){	return 0;} /* * Kill all tracing for good (never come back). * It is initialized to 1 but will turn to zero if the initialization * of the tracer is successful. But that is the only place that sets * this back to zero. */static int tracing_disabled = 1; DEFINE_PER_CPU(int, ftrace_cpu_disabled); static inline void ftrace_disable_cpu(void){	preempt_disable();	__this_cpu_inc(ftrace_cpu_disabled);} static inline void ftrace_enable_cpu(void){	__this_cpu_dec(ftrace_cpu_disabled);	preempt_enable();} cpumask_var_t __read_mostly	tracing_buffer_mask; /* * ftrace_dump_on_oops - variable to dump ftrace buffer on oops * * If there is an oops (or kernel panic) and the ftrace_dump_on_oops * is set, then ftrace_dump is called. This will output the contents * of the ftrace buffers to the console.  This is very useful for * capturing traces that lead to crashes and outputing it to a * serial console. * * It is default off, but you can enable it with either specifying * "ftrace_dump_on_oops" in the kernel command line, or setting * /proc/sys/kernel/ftrace_dump_on_oops * Set 1 if you want to dump buffers of all CPUs * Set 2 if you want to dump the buffer of the CPU that triggered oops */ enum ftrace_dump_mode ftrace_dump_on_oops; static int tracing_set_tracer(const char *buf); #define MAX_TRACER_SIZE		100static char bootup_tracer_buf[MAX_TRACER_SIZE] __initdata;static char *default_bootup_tracer; static int __init set_cmdline_ftrace(char *str){	strncpy(bootup_tracer_buf, str, MAX_TRACER_SIZE);	default_bootup_tracer = bootup_tracer_buf;	/* We are using ftrace early, expand it */	ring_buffer_expanded = 1;	return 1;}__setup("ftrace=", set_cmdline_ftrace); static int __init set_ftrace_dump_on_oops(char *str){	if (*str++ != '=' || !*str) {		ftrace_dump_on_oops = DUMP_ALL;		return 1;	} 	if (!strcmp("orig_cpu", str)) {		ftrace_dump_on_oops = DUMP_ORIG;                return 1;        }         return 0;}__setup("ftrace_dump_on_oops", set_ftrace_dump_on_oops); unsigned long long ns2usecs(cycle_t nsec){	nsec += 500;	do_div(nsec, 1000);	return nsec;} /* * The global_trace is the descriptor that holds the tracing * buffers for the live tracing. For each CPU, it contains * a link list of pages that will store trace entries. The * page descriptor of the pages in the memory is used to hold * the link list by linking the lru item in the page descriptor * to each of the pages in the buffer per CPU. * * For each active CPU there is a data field that holds the * pages for the buffer for that CPU. Each CPU has the same number * of pages allocated for its buffer. */static struct trace_array	global_trace; static DEFINE_PER_CPU(struct trace_array_cpu, global_trace_cpu); int filter_current_check_discard(struct ring_buffer *buffer,				 struct ftrace_event_call *call, void *rec,				 struct ring_buffer_event *event){	return filter_check_discard(call, rec, buffer, event);}EXPORT_SYMBOL_GPL(filter_current_check_discard); cycle_t ftrace_now(int cpu){	u64 ts; 	/* Early boot up does not have a buffer yet */	if (!global_trace.buffer)		return trace_clock_local(); 	ts = ring_buffer_time_stamp(global_trace.buffer, cpu);	ring_buffer_normalize_time_stamp(global_trace.buffer, cpu, &ts); 	return ts;} /* * The max_tr is used to snapshot the global_trace when a maximum * latency is reached. Some tracers will use this to store a maximum * trace while it continues examining live traces. * * The buffers for the max_tr are set up the same as the global_trace. * When a snapshot is taken, the link list of the max_tr is swapped * with the link list of the global_trace and the buffers are reset for * the global_trace so the tracing can continue. */static struct trace_array	max_tr; static DEFINE_PER_CPU(struct trace_array_cpu, max_tr_data); /* tracer_enabled is used to toggle activation of a tracer */static int			tracer_enabled = 1; /** * tracing_is_enabled - return tracer_enabled status * * This function is used by other tracers to know the status * of the tracer_enabled flag.  Tracers may use this function * to know if it should enable their features when starting * up. See irqsoff tracer for an example (start_irqsoff_tracer). */int tracing_is_enabled(void){	return tracer_enabled;} /* * trace_buf_size is the size in bytes that is allocated * for a buffer. Note, the number of bytes is always rounded * to page size. * * This number is purposely set to a low number of 16384. * If the dump on oops happens, it will be much appreciated * to not have to wait for all that output. Anyway this can be * boot time and run time configurable. */#define TRACE_BUF_SIZE_DEFAULT	1441792UL /* 16384 * 88 (sizeof(entry)) */ static unsigned long		trace_buf_size = TRACE_BUF_SIZE_DEFAULT; /* trace_types holds a link list of available tracers. */static struct tracer		*trace_types __read_mostly; /* current_trace points to the tracer that is currently active */static struct tracer		*current_trace __read_mostly; /* * trace_types_lock is used to protect the trace_types list. */static DEFINE_MUTEX(trace_types_lock); /* * serialize the access of the ring buffer * * ring buffer serializes readers, but it is low level protection. * The validity of the events (which returns by ring_buffer_peek() ..etc) * are not protected by ring buffer. * * The content of events may become garbage if we allow other process consumes * these events concurrently: *   A) the page of the consumed events may become a normal page *      (not reader page) in ring buffer, and this page will be rewrited *      by events producer. *   B) The page of the consumed events may become a page for splice_read, *      and this page will be returned to system. * * These primitives allow multi process access to different cpu ring buffer * concurrently. * * These primitives don't distinguish read-only and read-consume access. * Multi read-only access are also serialized. */ #ifdef CONFIG_SMPstatic DECLARE_RWSEM(all_cpu_access_lock);static DEFINE_PER_CPU(struct mutex, cpu_access_lock); static inline void trace_access_lock(int cpu){	if (cpu == TRACE_PIPE_ALL_CPU) {		/* gain it for accessing the whole ring buffer. */		down_write(&all_cpu_access_lock);	} else {		/* gain it for accessing a cpu ring buffer. */ 		/* Firstly block other trace_access_lock(TRACE_PIPE_ALL_CPU). */		down_read(&all_cpu_access_lock); 		/* Secondly block other access to this @cpu ring buffer. */		mutex_lock(&per_cpu(cpu_access_lock, cpu));	}} static inline void trace_access_unlock(int cpu){	if (cpu == TRACE_PIPE_ALL_CPU) {		up_write(&all_cpu_access_lock);	} else {		mutex_unlock(&per_cpu(cpu_access_lock, cpu));		up_read(&all_cpu_access_lock);	}} static inline void trace_access_lock_init(void){	int cpu; 	for_each_possible_cpu(cpu)		mutex_init(&per_cpu(cpu_access_lock, cpu));} #else static DEFINE_MUTEX(access_lock); static inline void trace_access_lock(int cpu){	(void)cpu;	mutex_lock(&access_lock);} static inline void trace_access_unlock(int cpu){	(void)cpu;	mutex_unlock(&access_lock);} static inline void trace_access_lock_init(void){} #endif /* trace_wait is a waitqueue for tasks blocked on trace_poll */static DECLARE_WAIT_QUEUE_HEAD(trace_wait); /* trace_flags holds trace_options default values */unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK |	TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO | TRACE_ITER_SLEEP_TIME |	TRACE_ITER_GRAPH_TIME | TRACE_ITER_RECORD_CMD | TRACE_ITER_OVERWRITE |	TRACE_ITER_IRQ_INFO; static int trace_stop_count;static DEFINE_RAW_SPINLOCK(tracing_start_lock); static void wakeup_work_handler(struct work_struct *work){	wake_up(&trace_wait);} static DECLARE_DELAYED_WORK(wakeup_work, wakeup_work_handler); /** * tracing_on - enable tracing buffers * * This function enables tracing buffers that may have been * disabled with tracing_off. */void tracing_on(void){	if (global_trace.buffer)		ring_buffer_record_on(global_trace.buffer);	/*	 * This flag is only looked at when buffers haven't been	 * allocated yet. We don't really care about the race	 * between setting this flag and actually turning	 * on the buffer.	 */	global_trace.buffer_disabled = 0;}EXPORT_SYMBOL_GPL(tracing_on); /** * tracing_off - turn off tracing buffers * * This function stops the tracing buffers from recording data. * It does not disable any overhead the tracers themselves may * be causing. This function simply causes all recording to * the ring buffers to fail. */void tracing_off(void){	if (global_trace.buffer)		ring_buffer_record_on(global_trace.buffer);	/*	 * This flag is only looked at when buffers haven't been	 * allocated yet. We don't really care about the race	 * between setting this flag and actually turning	 * on the buffer.	 */	global_trace.buffer_disabled = 1;}EXPORT_SYMBOL_GPL(tracing_off); /** * tracing_is_on - show state of ring buffers enabled */int tracing_is_on(void){	if (global_trace.buffer)		return ring_buffer_record_is_on(global_trace.buffer);	return !global_trace.buffer_disabled;}EXPORT_SYMBOL_GPL(tracing_is_on); /** * trace_wake_up - wake up tasks waiting for trace input * * Schedules a delayed work to wake up any task that is blocked on the * trace_wait queue. These is used with trace_poll for tasks polling the * trace. */void trace_wake_up(void){	const unsigned long delay = msecs_to_jiffies(2); 	if (trace_flags & TRACE_ITER_BLOCK)		return;	schedule_delayed_work(&wakeup_work, delay);} static int __init set_buf_size(char *str){	unsigned long buf_size; 	if (!str)		return 0;	buf_size = memparse(str, &str);	/* nr_entries can not be zero */	if (buf_size == 0)		return 0;	trace_buf_size = buf_size;	return 1;}__setup("trace_buf_size=", set_buf_size); static int __init set_tracing_thresh(char *str){	unsigned long threshhold;	int ret; 	if (!str)		return 0;	ret = strict_strtoul(str, 0, &threshhold);	if (ret < 0)		return 0;	tracing_thresh = threshhold * 1000;	return 1;}__setup("tracing_thresh=", set_tracing_thresh); unsigned long nsecs_to_usecs(unsigned long nsecs){	return nsecs / 1000;} /* These must match the bit postions in trace_iterator_flags */static const char *trace_options[] = {	"print-parent",	"sym-offset",	"sym-addr",	"verbose",	"raw",	"hex",	"bin",	"block",	"stacktrace",	"trace_printk",	"ftrace_preempt",	"branch",	"annotate",	"userstacktrace",	"sym-userobj",	"printk-msg-only",	"context-info",	"latency-format",	"sleep-time",	"graph-time",	"record-cmd",	"overwrite",	"disable_on_free",	"irq-info",	NULL}; static struct {	u64 (*func)(void);	const char *name;} trace_clocks[] = {	{ trace_clock_local,	"local" },	{ trace_clock_global,	"global" },	{ trace_clock_counter,	"counter" },}; int trace_clock_id; /* * trace_parser_get_init - gets the buffer for trace parser

Lines 1–500 of 5043. Load more