/* * trace_output.c * * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> * */ #include <linux/module.h>#include <linux/mutex.h>#include <linux/ftrace.h> #include "trace_output.h" /* must be a power of 2 */#define EVENT_HASHSIZE	128 DECLARE_RWSEM(trace_event_sem); static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly; static int next_event_type = __TRACE_LAST_TYPE + 1; enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter){	struct trace_seq *s = &iter->seq;	struct trace_entry *entry = iter->ent;	struct bputs_entry *field; 	trace_assign_type(field, entry); 	trace_seq_puts(s, field->str); 	return trace_handle_return(s);} enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter){	struct trace_seq *s = &iter->seq;	struct trace_entry *entry = iter->ent;	struct bprint_entry *field; 	trace_assign_type(field, entry); 	trace_seq_bprintf(s, field->fmt, field->buf); 	return trace_handle_return(s);} enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter){	struct trace_seq *s = &iter->seq;	struct trace_entry *entry = iter->ent;	struct print_entry *field; 	trace_assign_type(field, entry); 	trace_seq_puts(s, field->buf); 	return trace_handle_return(s);} const char *trace_print_flags_seq(struct trace_seq *p, const char *delim,		      unsigned long flags,		      const struct trace_print_flags *flag_array){	unsigned long mask;	const char *str;	const char *ret = trace_seq_buffer_ptr(p);	int i, first = 1; 	for (i = 0;  flag_array[i].name && flags; i++) { 		mask = flag_array[i].mask;		if ((flags & mask) != mask)			continue; 		str = flag_array[i].name;		flags &= ~mask;		if (!first && delim)			trace_seq_puts(p, delim);		else			first = 0;		trace_seq_puts(p, str);	} 	/* check for left over flags */	if (flags) {		if (!first && delim)			trace_seq_puts(p, delim);		trace_seq_printf(p, "0x%lx", flags);	} 	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_flags_seq); const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val,			const struct trace_print_flags *symbol_array){	int i;	const char *ret = trace_seq_buffer_ptr(p); 	for (i = 0;  symbol_array[i].name; i++) { 		if (val != symbol_array[i].mask)			continue; 		trace_seq_puts(p, symbol_array[i].name);		break;	} 	if (ret == (const char *)(trace_seq_buffer_ptr(p)))		trace_seq_printf(p, "0x%lx", val); 	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_symbols_seq); #if BITS_PER_LONG == 32const char *trace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,			 const struct trace_print_flags_u64 *symbol_array){	int i;	const char *ret = trace_seq_buffer_ptr(p); 	for (i = 0;  symbol_array[i].name; i++) { 		if (val != symbol_array[i].mask)			continue; 		trace_seq_puts(p, symbol_array[i].name);		break;	} 	if (ret == (const char *)(trace_seq_buffer_ptr(p)))		trace_seq_printf(p, "0x%llx", val); 	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_symbols_seq_u64);#endif const char *trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,			unsigned int bitmask_size){	const char *ret = trace_seq_buffer_ptr(p); 	trace_seq_bitmask(p, bitmask_ptr, bitmask_size * 8);	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL_GPL(trace_print_bitmask_seq); const char *trace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len){	int i;	const char *ret = trace_seq_buffer_ptr(p); 	for (i = 0; i < buf_len; i++)		trace_seq_printf(p, "%s%2.2x", i == 0 ? "" : " ", buf[i]); 	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_hex_seq); const char *trace_print_array_seq(struct trace_seq *p, const void *buf, int count,		      size_t el_size){	const char *ret = trace_seq_buffer_ptr(p);	const char *prefix = "";	void *ptr = (void *)buf;	size_t buf_len = count * el_size; 	trace_seq_putc(p, '{'); 	while (ptr < buf + buf_len) {		switch (el_size) {		case 1:			trace_seq_printf(p, "%s0x%x", prefix,					 *(u8 *)ptr);			break;		case 2:			trace_seq_printf(p, "%s0x%x", prefix,					 *(u16 *)ptr);			break;		case 4:			trace_seq_printf(p, "%s0x%x", prefix,					 *(u32 *)ptr);			break;		case 8:			trace_seq_printf(p, "%s0x%llx", prefix,					 *(u64 *)ptr);			break;		default:			trace_seq_printf(p, "BAD SIZE:%zu 0x%x", el_size,					 *(u8 *)ptr);			el_size = 1;		}		prefix = ",";		ptr += el_size;	} 	trace_seq_putc(p, '}');	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_array_seq); int trace_raw_output_prep(struct trace_iterator *iter,			  struct trace_event *trace_event){	struct trace_event_call *event;	struct trace_seq *s = &iter->seq;	struct trace_seq *p = &iter->tmp_seq;	struct trace_entry *entry; 	event = container_of(trace_event, struct trace_event_call, event);	entry = iter->ent; 	if (entry->type != event->event.type) {		WARN_ON_ONCE(1);		return TRACE_TYPE_UNHANDLED;	} 	trace_seq_init(p);	trace_seq_printf(s, "%s: ", trace_event_name(event)); 	return trace_handle_return(s);}EXPORT_SYMBOL(trace_raw_output_prep); static int trace_output_raw(struct trace_iterator *iter, char *name,			    char *fmt, va_list ap){	struct trace_seq *s = &iter->seq; 	trace_seq_printf(s, "%s: ", name);	trace_seq_vprintf(s, fmt, ap); 	return trace_handle_return(s);} int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...){	va_list ap;	int ret; 	va_start(ap, fmt);	ret = trace_output_raw(iter, name, fmt, ap);	va_end(ap); 	return ret;}EXPORT_SYMBOL_GPL(trace_output_call); #ifdef CONFIG_KRETPROBESstatic 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;}#elsestatic inline const char *kretprobed(const char *name){	return name;}#endif /* CONFIG_KRETPROBES */ static voidseq_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); 	trace_seq_printf(s, fmt, name);#endif} static voidseq_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); 	trace_seq_printf(s, fmt, name);#endif} #ifndef CONFIG_64BIT# define IP_FMT "%08lx"#else# define IP_FMT "%016lx"#endif static 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 (s->full)		return 0; 	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)				trace_seq_printf(s, "[+0x%lx]",						 ip - vmstart);		}		up_read(&mm->mmap_sem);	}	if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))		trace_seq_printf(s, " <" IP_FMT ">", ip);	return !trace_seq_has_overflowed(s);} intseq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags){	if (!ip) {		trace_seq_putc(s, '0');		goto out;	} 	if (sym_flags & TRACE_ITER_SYM_OFFSET)		seq_print_sym_offset(s, "%s", ip);	else		seq_print_sym_short(s, "%s", ip); 	if (sym_flags & TRACE_ITER_SYM_ADDR)		trace_seq_printf(s, " <" IP_FMT ">", ip);  out:	return !trace_seq_has_overflowed(s);} /** * trace_print_lat_fmt - print the irq, preempt and lockdep fields * @s: trace seq struct to write to * @entry: The trace entry field from the ring buffer * * Prints the generic fields of irqs off, in hard or softirq, preempt * count. */int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry){	char hardsoft_irq;	char need_resched;	char irqs_off;	int hardirq;	int softirq; 	hardirq = entry->flags & TRACE_FLAG_HARDIRQ;	softirq = entry->flags & TRACE_FLAG_SOFTIRQ; 	irqs_off =		(entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :		(entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' :		'.'; 	switch (entry->flags & (TRACE_FLAG_NEED_RESCHED |				TRACE_FLAG_PREEMPT_RESCHED)) {	case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED:		need_resched = 'N';		break;	case TRACE_FLAG_NEED_RESCHED:		need_resched = 'n';		break;	case TRACE_FLAG_PREEMPT_RESCHED:		need_resched = 'p';		break;	default:		need_resched = '.';		break;	} 	hardsoft_irq =		(hardirq && softirq) ? 'H' :		hardirq ? 'h' :		softirq ? 's' :		'.'; 	trace_seq_printf(s, "%c%c%c",			 irqs_off, need_resched, hardsoft_irq); 	if (entry->preempt_count)		trace_seq_printf(s, "%x", entry->preempt_count);	else		trace_seq_putc(s, '.'); 	return !trace_seq_has_overflowed(s);} static intlat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu){	char comm[TASK_COMM_LEN]; 	trace_find_cmdline(entry->pid, comm); 	trace_seq_printf(s, "%8.8s-%-5d %3d",			 comm, entry->pid, cpu); 	return trace_print_lat_fmt(s, entry);} #undef MARK#define MARK(v, s) {.val = v, .sym = s}/* trace overhead mark */static const struct trace_mark {	unsigned long long	val; /* unit: nsec */	char			sym;} mark[] = {	MARK(1000000000ULL	, '$'), /* 1 sec */	MARK(100000000ULL	, '@'), /* 100 msec */	MARK(10000000ULL	, '*'), /* 10 msec */	MARK(1000000ULL		, '#'), /* 1000 usecs */	MARK(100000ULL		, '!'), /* 100 usecs */	MARK(10000ULL		, '+'), /* 10 usecs */};#undef MARK char trace_find_mark(unsigned long long d){	int i;	int size = ARRAY_SIZE(mark); 	for (i = 0; i < size; i++) {		if (d > mark[i].val)			break;	} 	return (i == size) ? ' ' : mark[i].sym;} static intlat_print_timestamp(struct trace_iterator *iter, u64 next_ts){	struct trace_array *tr = iter->tr;	unsigned long verbose = tr->trace_flags & TRACE_ITER_VERBOSE;	unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;	unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start;	unsigned long long rel_ts = next_ts - iter->ts;	struct trace_seq *s = &iter->seq; 	if (in_ns) {		abs_ts = ns2usecs(abs_ts);		rel_ts = ns2usecs(rel_ts);	} 	if (verbose && in_ns) {		unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC);		unsigned long abs_msec = (unsigned long)abs_ts;		unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);		unsigned long rel_msec = (unsigned long)rel_ts; 		trace_seq_printf(			s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",			ns2usecs(iter->ts),			abs_msec, abs_usec,

Lines 1–500 of 1253. Load more