// SPDX-License-Identifier: GPL-2.0/* * 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 <linux/kprobes.h>#include <linux/sched/clock.h>#include <linux/sched/mm.h>#include <linux/idr.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; 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_flags_seq_u64(struct trace_seq *p, const char *delim,		      unsigned long long flags,		      const struct trace_print_flags_u64 *flag_array){	unsigned long 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%llx", flags);	} 	trace_seq_putc(p, 0); 	return ret;}EXPORT_SYMBOL(trace_print_flags_seq_u64); const 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); /** * trace_print_hex_seq - print buffer as hex sequence * @p: trace seq struct to write to * @buf: The buffer to print * @buf_len: Length of @buf in bytes * @concatenate: Print @buf as single hex string or with spacing * * Prints the passed buffer as a hex sequence either as a whole, * single hex string if @concatenate is true or with spacing after * each byte in case @concatenate is false. */const char *trace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len,		    bool concatenate){	int i;	const char *ret = trace_seq_buffer_ptr(p);	const char *fmt = concatenate ? "%*phN" : "%*ph"; 	for (i = 0; i < buf_len; i += 16) {		if (!concatenate && i != 0)			trace_seq_putc(p, ' ');		trace_seq_printf(p, fmt, min(buf_len - i, 16), &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); const char *trace_print_hex_dump_seq(struct trace_seq *p, const char *prefix_str,			 int prefix_type, int rowsize, int groupsize,			 const void *buf, size_t len, bool ascii){	const char *ret = trace_seq_buffer_ptr(p); 	trace_seq_putc(p, '\n');	trace_seq_hex_dump(p, prefix_str, prefix_type,			   rowsize, groupsize, buf, len, ascii);	trace_seq_putc(p, 0);	return ret;}EXPORT_SYMBOL(trace_print_hex_dump_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); void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...){	va_list ap; 	va_start(ap, fmt);	trace_check_vprintf(iter, trace_event_format(iter, fmt), ap);	va_end(ap);}EXPORT_SYMBOL(trace_event_printf); static __printf(3, 0)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, trace_event_format(iter, 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); static inline const char *kretprobed(const char *name, unsigned long addr){	if (is_kretprobe_trampoline(addr))		return "[unknown/kretprobe'd]";	return name;} voidtrace_seq_print_sym(struct trace_seq *s, unsigned long address, bool offset){#ifdef CONFIG_KALLSYMS	char str[KSYM_SYMBOL_LEN];	const char *name; 	if (offset)		sprint_symbol(str, address);	else		kallsyms_lookup(address, NULL, NULL, NULL, str);	name = kretprobed(str, address); 	if (name && strlen(name)) {		trace_seq_puts(s, name);		return;	}#endif	trace_seq_printf(s, "0x%08lx", address);} #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; 		mmap_read_lock(mm);		vma = find_vma(mm, ip);		if (vma) {			file = vma->vm_file;			vmstart = vma->vm_start;		}		if (file) {			ret = trace_seq_path(s, file_user_path(file));			if (ret)				trace_seq_printf(s, "[+0x%lx]",						 ip - vmstart);		}		mmap_read_unlock(mm);	}	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;	} 	trace_seq_print_sym(s, ip, sym_flags & TRACE_ITER_SYM_OFFSET); 	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;	int bh_off;	int nmi; 	nmi = entry->flags & TRACE_FLAG_NMI;	hardirq = entry->flags & TRACE_FLAG_HARDIRQ;	softirq = entry->flags & TRACE_FLAG_SOFTIRQ;	bh_off = entry->flags & TRACE_FLAG_BH_OFF; 	irqs_off =		(entry->flags & TRACE_FLAG_IRQS_OFF && bh_off) ? 'D' :		(entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :		bh_off ? 'b' :		(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 =		(nmi && hardirq)     ? 'Z' :		nmi                  ? 'z' :		(hardirq && softirq) ? 'H' :		hardirq              ? 'h' :		softirq              ? 's' :		                       '.' ; 	trace_seq_printf(s, "%c%c%c",			 irqs_off, need_resched, hardsoft_irq); 	if (entry->preempt_count & 0xf)		trace_seq_printf(s, "%x", entry->preempt_count & 0xf);	else		trace_seq_putc(s, '.'); 	if (entry->preempt_count & 0xf0)		trace_seq_printf(s, "%x", entry->preempt_count >> 4);	else

Lines 1–500 of 1732. Load more