/* * ring buffer based function tracer * * Copyright (C) 2007-2012 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 Nadia Yvette Chambers */#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 <linux/sched/rt.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. */bool 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;} /* * To prevent the comm cache from being overwritten when no * tracing is active, only save the comm when a trace event * occurred. */static DEFINE_PER_CPU(bool, trace_cmdline_save); /* * 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); 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 bool allocate_snapshot; static int __init set_cmdline_ftrace(char *str){	strlcpy(bootup_tracer_buf, str, MAX_TRACER_SIZE);	default_bootup_tracer = bootup_tracer_buf;	/* We are using ftrace early, expand it */	ring_buffer_expanded = true;	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); static int __init boot_alloc_snapshot(char *str){	allocate_snapshot = true;	/* We also need the main ring buffer expanded */	ring_buffer_expanded = true;	return 1;}__setup("alloc_snapshot", boot_alloc_snapshot);  static char trace_boot_options_buf[MAX_TRACER_SIZE] __initdata;static char *trace_boot_options __initdata; static int __init set_trace_boot_options(char *str){	strlcpy(trace_boot_options_buf, str, MAX_TRACER_SIZE);	trace_boot_options = trace_boot_options_buf;	return 0;}__setup("trace_options=", set_trace_boot_options); 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; LIST_HEAD(ftrace_trace_arrays); 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.trace_buffer.buffer)		return trace_clock_local(); 	ts = ring_buffer_time_stamp(global_trace.trace_buffer.buffer, cpu);	ring_buffer_normalize_time_stamp(global_trace.trace_buffer.buffer, cpu, &ts); 	return ts;} int tracing_is_enabled(void){	return tracing_is_on();} /* * 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; /* * 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 == RING_BUFFER_ALL_CPUS) {		/* 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(RING_BUFFER_ALL_CPUS). */		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 == RING_BUFFER_ALL_CPUS) {		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_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 | TRACE_ITER_MARKERS | TRACE_ITER_FUNCTION; /** * 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.trace_buffer.buffer)		ring_buffer_record_on(global_trace.trace_buffer.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); /** * __trace_puts - write a constant string into the trace buffer. * @ip:	   The address of the caller * @str:   The constant string to write * @size:  The size of the string. */int __trace_puts(unsigned long ip, const char *str, int size){	struct ring_buffer_event *event;	struct ring_buffer *buffer;	struct print_entry *entry;	unsigned long irq_flags;	int alloc; 	alloc = sizeof(*entry) + size + 2; /* possible \n added */ 	local_save_flags(irq_flags);	buffer = global_trace.trace_buffer.buffer;	event = trace_buffer_lock_reserve(buffer, TRACE_PRINT, alloc, 					  irq_flags, preempt_count());	if (!event)		return 0; 	entry = ring_buffer_event_data(event);	entry->ip = ip; 	memcpy(&entry->buf, str, size); 	/* Add a newline if necessary */	if (entry->buf[size - 1] != '\n') {		entry->buf[size] = '\n';		entry->buf[size + 1] = '\0';	} else		entry->buf[size] = '\0'; 	__buffer_unlock_commit(buffer, event); 	return size;}EXPORT_SYMBOL_GPL(__trace_puts); /** * __trace_bputs - write the pointer to a constant string into trace buffer * @ip:	   The address of the caller * @str:   The constant string to write to the buffer to */int __trace_bputs(unsigned long ip, const char *str){	struct ring_buffer_event *event;	struct ring_buffer *buffer;	struct bputs_entry *entry;	unsigned long irq_flags;	int size = sizeof(struct bputs_entry); 	local_save_flags(irq_flags);	buffer = global_trace.trace_buffer.buffer;	event = trace_buffer_lock_reserve(buffer, TRACE_BPUTS, size,					  irq_flags, preempt_count());	if (!event)		return 0; 	entry = ring_buffer_event_data(event);	entry->ip			= ip;	entry->str			= str; 	__buffer_unlock_commit(buffer, event); 	return 1;}EXPORT_SYMBOL_GPL(__trace_bputs); #ifdef CONFIG_TRACER_SNAPSHOT/** * trace_snapshot - take a snapshot of the current buffer. * * This causes a swap between the snapshot buffer and the current live * tracing buffer. You can use this to take snapshots of the live * trace when some condition is triggered, but continue to trace. * * Note, make sure to allocate the snapshot with either * a tracing_snapshot_alloc(), or by doing it manually * with: echo 1 > /sys/kernel/debug/tracing/snapshot * * If the snapshot buffer is not allocated, it will stop tracing. * Basically making a permanent snapshot. */void tracing_snapshot(void){	struct trace_array *tr = &global_trace;	struct tracer *tracer = tr->current_trace;	unsigned long flags; 	if (in_nmi()) {		internal_trace_puts("*** SNAPSHOT CALLED FROM NMI CONTEXT ***\n");		internal_trace_puts("*** snapshot is being ignored        ***\n");		return;	} 	if (!tr->allocated_snapshot) {		internal_trace_puts("*** SNAPSHOT NOT ALLOCATED ***\n");		internal_trace_puts("*** stopping trace here!   ***\n");		tracing_off();		return;	} 	/* Note, snapshot can not be used when the tracer uses it */	if (tracer->use_max_tr) {		internal_trace_puts("*** LATENCY TRACER ACTIVE ***\n");		internal_trace_puts("*** Can not use snapshot (sorry) ***\n");		return;	} 	local_irq_save(flags);	update_max_tr(tr, current, smp_processor_id());	local_irq_restore(flags);}EXPORT_SYMBOL_GPL(tracing_snapshot); static int resize_buffer_duplicate_size(struct trace_buffer *trace_buf,					struct trace_buffer *size_buf, int cpu_id);static void set_buffer_entries(struct trace_buffer *buf, unsigned long val); static int alloc_snapshot(struct trace_array *tr){	int ret; 	if (!tr->allocated_snapshot) { 		/* allocate spare buffer */		ret = resize_buffer_duplicate_size(&tr->max_buffer,				   &tr->trace_buffer, RING_BUFFER_ALL_CPUS);		if (ret < 0)			return ret; 		tr->allocated_snapshot = true;	} 	return 0;} void free_snapshot(struct trace_array *tr){	/*	 * We don't free the ring buffer. instead, resize it because	 * The max_tr ring buffer has some state (e.g. ring->clock) and	 * we want preserve it.	 */	ring_buffer_resize(tr->max_buffer.buffer, 1, RING_BUFFER_ALL_CPUS);

Lines 1–500 of 6296. Load more