Commit f0868d1e authored by Steven Rostedt's avatar Steven Rostedt Committed by Ingo Molnar
Browse files

ftrace: set up trace event hash infrastructure 



Impact: simplify/generalize/refactor trace.c

The trace.c file is becoming more difficult to maintain due to the
growing number of events. There is several formats that an event may
be printed. This patch sets up the infrastructure of an event hash to
allow for events to register how they should be printed.

Signed-off-by: default avatarSteven Rostedt <srostedt@redhat.com>
Signed-off-by: default avatarIngo Molnar <mingo@elte.hu>
parent c47956d9

kernel/trace/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ obj-$(CONFIG_FUNCTION_TRACER) += libftrace.o 
obj-$(CONFIG_RING_BUFFER) += ring_buffer.o



obj-$(CONFIG_TRACING) += trace.o

obj-$(CONFIG_TRACING) += trace_output.o

obj-$(CONFIG_CONTEXT_SWITCH_TRACER) += trace_sched_switch.o

obj-$(CONFIG_SYSPROF_TRACER) += trace_sysprof.o

obj-$(CONFIG_FUNCTION_TRACER) += trace_functions.o

kernel/trace/trace.c

+1 −274
Original line number Diff line number Diff line
@@ -38,6 +38,7 @@ 
#include <linux/irqflags.h>



#include "trace.h"

#include "trace_output.h"



#define TRACE_BUFFER_FLAGS	(RB_FL_OVERWRITE)
@@ -330,132 +331,6 @@ __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu) 
	tracing_record_cmdline(current);

}



/**

 * trace_seq_printf - sequence printing of trace information

 * @s: trace sequence descriptor

 * @fmt: printf format string

 *

 * The tracer may use either sequence operations or its own

 * copy to user routines. To simplify formating of a trace

 * trace_seq_printf is used to store strings into a special

 * buffer (@s). Then the output may be either used by

 * the sequencer or pulled into another buffer.

 */

int

trace_seq_printf(struct trace_seq *s, const char *fmt, ...)

{

	int len = (PAGE_SIZE - 1) - s->len;

	va_list ap;

	int ret;



	if (!len)

		return 0;



	va_start(ap, fmt);

	ret = vsnprintf(s->buffer + s->len, len, fmt, ap);

	va_end(ap);



	/* If we can't write it all, don't bother writing anything */

	if (ret >= len)

		return 0;



	s->len += ret;



	return len;

}



/**

 * trace_seq_puts - trace sequence printing of simple string

 * @s: trace sequence descriptor

 * @str: simple string to record

 *

 * The tracer may use either the sequence operations or its own

 * copy to user routines. This function records a simple string

 * into a special buffer (@s) for later retrieval by a sequencer

 * or other mechanism.

 */

static int

trace_seq_puts(struct trace_seq *s, const char *str)

{

	int len = strlen(str);



	if (len > ((PAGE_SIZE - 1) - s->len))

		return 0;



	memcpy(s->buffer + s->len, str, len);

	s->len += len;



	return len;

}



static int

trace_seq_putc(struct trace_seq *s, unsigned char c)

{

	if (s->len >= (PAGE_SIZE - 1))

		return 0;



	s->buffer[s->len++] = c;



	return 1;

}



static int

trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)

{

	if (len > ((PAGE_SIZE - 1) - s->len))

		return 0;



	memcpy(s->buffer + s->len, mem, len);

	s->len += len;



	return len;

}



#define MAX_MEMHEX_BYTES	8

#define HEX_CHARS		(MAX_MEMHEX_BYTES*2 + 1)



static int

trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)

{

	unsigned char hex[HEX_CHARS];

	unsigned char *data = mem;

	int i, j;



#ifdef __BIG_ENDIAN

	for (i = 0, j = 0; i < len; i++) {

#else

	for (i = len-1, j = 0; i >= 0; i--) {

#endif

		hex[j++] = hex_asc_hi(data[i]);

		hex[j++] = hex_asc_lo(data[i]);

	}

	hex[j++] = ' ';



	return trace_seq_putmem(s, hex, j);

}



static int

trace_seq_path(struct trace_seq *s, struct path *path)

{

	unsigned char *p;



	if (s->len >= (PAGE_SIZE - 1))

		return 0;

	p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);

	if (!IS_ERR(p)) {

		p = mangle_path(s->buffer + s->len, p, "\n");

		if (p) {

			s->len = p - s->buffer;

			return 1;

		}

	} else {

		s->buffer[s->len++] = '?';

		return 1;

	}



	return 0;

}



static void

trace_seq_reset(struct trace_seq *s)

{
@@ -1473,154 +1348,6 @@ static void s_stop(struct seq_file *m, void *p) 
	mutex_unlock(&trace_types_lock);

}



#ifdef CONFIG_KRETPROBES

static inline const char *kretprobed(const char *name)

{

	static const char tramp_name[] = "kretprobe_trampoline";

	int size = sizeof(tramp_name);



	if (strncmp(tramp_name, name, size) == 0)

		return "[unknown/kretprobe'd]";

	return name;

}

#else

static inline const char *kretprobed(const char *name)

{

	return name;

}

#endif /* CONFIG_KRETPROBES */



static int

seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)

{

#ifdef CONFIG_KALLSYMS

	char str[KSYM_SYMBOL_LEN];

	const char *name;



	kallsyms_lookup(address, NULL, NULL, NULL, str);



	name = kretprobed(str);



	return trace_seq_printf(s, fmt, name);

#endif

	return 1;

}



static int

seq_print_sym_offset(struct trace_seq *s, const char *fmt,

		     unsigned long address)

{

#ifdef CONFIG_KALLSYMS

	char str[KSYM_SYMBOL_LEN];

	const char *name;



	sprint_symbol(str, address);

	name = kretprobed(str);



	return trace_seq_printf(s, fmt, name);

#endif

	return 1;

}



#ifndef CONFIG_64BIT

# define IP_FMT "%08lx"

#else

# define IP_FMT "%016lx"

#endif



int

seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)

{

	int ret;



	if (!ip)

		return trace_seq_printf(s, "0");



	if (sym_flags & TRACE_ITER_SYM_OFFSET)

		ret = seq_print_sym_offset(s, "%s", ip);

	else

		ret = seq_print_sym_short(s, "%s", ip);



	if (!ret)

		return 0;



	if (sym_flags & TRACE_ITER_SYM_ADDR)

		ret = trace_seq_printf(s, " <" IP_FMT ">", ip);

	return ret;

}



static inline int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,

				    unsigned long ip, unsigned long sym_flags)

{

	struct file *file = NULL;

	unsigned long vmstart = 0;

	int ret = 1;



	if (mm) {

		const struct vm_area_struct *vma;



		down_read(&mm->mmap_sem);

		vma = find_vma(mm, ip);

		if (vma) {

			file = vma->vm_file;

			vmstart = vma->vm_start;

		}

		if (file) {

			ret = trace_seq_path(s, &file->f_path);

			if (ret)

				ret = trace_seq_printf(s, "[+0x%lx]", ip - vmstart);

		}

		up_read(&mm->mmap_sem);

	}

	if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))

		ret = trace_seq_printf(s, " <" IP_FMT ">", ip);

	return ret;

}



static int

seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,

		      unsigned long sym_flags)

{

	struct mm_struct *mm = NULL;

	int ret = 1;

	unsigned int i;



	if (trace_flags & TRACE_ITER_SYM_USEROBJ) {

		struct task_struct *task;

		/*

		 * we do the lookup on the thread group leader,

		 * since individual threads might have already quit!

		 */

		rcu_read_lock();

		task = find_task_by_vpid(entry->ent.tgid);

		if (task)

			mm = get_task_mm(task);

		rcu_read_unlock();

	}



	for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {

		unsigned long ip = entry->caller[i];



		if (ip == ULONG_MAX || !ret)

			break;

		if (i && ret)

			ret = trace_seq_puts(s, " <- ");

		if (!ip) {

			if (ret)

				ret = trace_seq_puts(s, "??");

			continue;

		}

		if (!ret)

			break;

		if (ret)

			ret = seq_print_user_ip(s, mm, ip, sym_flags);

	}



	if (mm)

		mmput(mm);

	return ret;

}



static void print_lat_help_header(struct seq_file *m)

{

	seq_puts(m, "#                  _------=> CPU#            \n");

kernel/trace/trace.h

+1 −7
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ enum trace_type { 
	TRACE_HW_BRANCHES,

	TRACE_POWER,



	__TRACE_LAST_TYPE

	__TRACE_LAST_TYPE,

};



/*
@@ -484,12 +484,6 @@ extern int trace_selftest_startup_branch(struct tracer *trace, 
#endif /* CONFIG_FTRACE_STARTUP_TEST */



extern void *head_page(struct trace_array_cpu *data);

extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...);

extern int

seq_print_ip_sym(struct trace_seq *s, unsigned long ip,

		unsigned long sym_flags);

extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf,

				 size_t cnt);

extern long ns2usecs(cycle_t nsec);

extern int

trace_vprintk(unsigned long ip, int depth, const char *fmt, va_list args);

kernel/trace/trace_boot.c

+1 −0
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include <linux/kallsyms.h>



#include "trace.h"

#include "trace_output.h"



static struct trace_array *boot_trace;

static bool pre_initcalls_finished;

kernel/trace/trace_functions_graph.c

+1 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
#include <linux/fs.h>



#include "trace.h"

#include "trace_output.h"



#define TRACE_GRAPH_INDENT	2

CRA Git | Maintained and supported by SUSTech CRA and CCSE