xref: /openbmc/linux/kernel/trace/trace_output.c (revision 0df76142)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * trace_output.c
4  *
5  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
6  *
7  */
8 #include <linux/module.h>
9 #include <linux/mutex.h>
10 #include <linux/ftrace.h>
11 #include <linux/kprobes.h>
12 #include <linux/sched/clock.h>
13 #include <linux/sched/mm.h>
14 #include <linux/idr.h>
15 
16 #include "trace_output.h"
17 
18 /* must be a power of 2 */
19 #define EVENT_HASHSIZE	128
20 
21 DECLARE_RWSEM(trace_event_sem);
22 
23 static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
24 
25 enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter)
26 {
27 	struct trace_seq *s = &iter->seq;
28 	struct trace_entry *entry = iter->ent;
29 	struct bputs_entry *field;
30 
31 	trace_assign_type(field, entry);
32 
33 	trace_seq_puts(s, field->str);
34 
35 	return trace_handle_return(s);
36 }
37 
38 enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
39 {
40 	struct trace_seq *s = &iter->seq;
41 	struct trace_entry *entry = iter->ent;
42 	struct bprint_entry *field;
43 
44 	trace_assign_type(field, entry);
45 
46 	trace_seq_bprintf(s, field->fmt, field->buf);
47 
48 	return trace_handle_return(s);
49 }
50 
51 enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
52 {
53 	struct trace_seq *s = &iter->seq;
54 	struct trace_entry *entry = iter->ent;
55 	struct print_entry *field;
56 
57 	trace_assign_type(field, entry);
58 
59 	trace_seq_puts(s, field->buf);
60 
61 	return trace_handle_return(s);
62 }
63 
64 const char *
65 trace_print_flags_seq(struct trace_seq *p, const char *delim,
66 		      unsigned long flags,
67 		      const struct trace_print_flags *flag_array)
68 {
69 	unsigned long mask;
70 	const char *str;
71 	const char *ret = trace_seq_buffer_ptr(p);
72 	int i, first = 1;
73 
74 	for (i = 0;  flag_array[i].name && flags; i++) {
75 
76 		mask = flag_array[i].mask;
77 		if ((flags & mask) != mask)
78 			continue;
79 
80 		str = flag_array[i].name;
81 		flags &= ~mask;
82 		if (!first && delim)
83 			trace_seq_puts(p, delim);
84 		else
85 			first = 0;
86 		trace_seq_puts(p, str);
87 	}
88 
89 	/* check for left over flags */
90 	if (flags) {
91 		if (!first && delim)
92 			trace_seq_puts(p, delim);
93 		trace_seq_printf(p, "0x%lx", flags);
94 	}
95 
96 	trace_seq_putc(p, 0);
97 
98 	return ret;
99 }
100 EXPORT_SYMBOL(trace_print_flags_seq);
101 
102 const char *
103 trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
104 			const struct trace_print_flags *symbol_array)
105 {
106 	int i;
107 	const char *ret = trace_seq_buffer_ptr(p);
108 
109 	for (i = 0;  symbol_array[i].name; i++) {
110 
111 		if (val != symbol_array[i].mask)
112 			continue;
113 
114 		trace_seq_puts(p, symbol_array[i].name);
115 		break;
116 	}
117 
118 	if (ret == (const char *)(trace_seq_buffer_ptr(p)))
119 		trace_seq_printf(p, "0x%lx", val);
120 
121 	trace_seq_putc(p, 0);
122 
123 	return ret;
124 }
125 EXPORT_SYMBOL(trace_print_symbols_seq);
126 
127 #if BITS_PER_LONG == 32
128 const char *
129 trace_print_flags_seq_u64(struct trace_seq *p, const char *delim,
130 		      unsigned long long flags,
131 		      const struct trace_print_flags_u64 *flag_array)
132 {
133 	unsigned long long mask;
134 	const char *str;
135 	const char *ret = trace_seq_buffer_ptr(p);
136 	int i, first = 1;
137 
138 	for (i = 0;  flag_array[i].name && flags; i++) {
139 
140 		mask = flag_array[i].mask;
141 		if ((flags & mask) != mask)
142 			continue;
143 
144 		str = flag_array[i].name;
145 		flags &= ~mask;
146 		if (!first && delim)
147 			trace_seq_puts(p, delim);
148 		else
149 			first = 0;
150 		trace_seq_puts(p, str);
151 	}
152 
153 	/* check for left over flags */
154 	if (flags) {
155 		if (!first && delim)
156 			trace_seq_puts(p, delim);
157 		trace_seq_printf(p, "0x%llx", flags);
158 	}
159 
160 	trace_seq_putc(p, 0);
161 
162 	return ret;
163 }
164 EXPORT_SYMBOL(trace_print_flags_seq_u64);
165 
166 const char *
167 trace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
168 			 const struct trace_print_flags_u64 *symbol_array)
169 {
170 	int i;
171 	const char *ret = trace_seq_buffer_ptr(p);
172 
173 	for (i = 0;  symbol_array[i].name; i++) {
174 
175 		if (val != symbol_array[i].mask)
176 			continue;
177 
178 		trace_seq_puts(p, symbol_array[i].name);
179 		break;
180 	}
181 
182 	if (ret == (const char *)(trace_seq_buffer_ptr(p)))
183 		trace_seq_printf(p, "0x%llx", val);
184 
185 	trace_seq_putc(p, 0);
186 
187 	return ret;
188 }
189 EXPORT_SYMBOL(trace_print_symbols_seq_u64);
190 #endif
191 
192 const char *
193 trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
194 			unsigned int bitmask_size)
195 {
196 	const char *ret = trace_seq_buffer_ptr(p);
197 
198 	trace_seq_bitmask(p, bitmask_ptr, bitmask_size * 8);
199 	trace_seq_putc(p, 0);
200 
201 	return ret;
202 }
203 EXPORT_SYMBOL_GPL(trace_print_bitmask_seq);
204 
205 /**
206  * trace_print_hex_seq - print buffer as hex sequence
207  * @p: trace seq struct to write to
208  * @buf: The buffer to print
209  * @buf_len: Length of @buf in bytes
210  * @concatenate: Print @buf as single hex string or with spacing
211  *
212  * Prints the passed buffer as a hex sequence either as a whole,
213  * single hex string if @concatenate is true or with spacing after
214  * each byte in case @concatenate is false.
215  */
216 const char *
217 trace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len,
218 		    bool concatenate)
219 {
220 	int i;
221 	const char *ret = trace_seq_buffer_ptr(p);
222 	const char *fmt = concatenate ? "%*phN" : "%*ph";
223 
224 	for (i = 0; i < buf_len; i += 16) {
225 		if (!concatenate && i != 0)
226 			trace_seq_putc(p, ' ');
227 		trace_seq_printf(p, fmt, min(buf_len - i, 16), &buf[i]);
228 	}
229 	trace_seq_putc(p, 0);
230 
231 	return ret;
232 }
233 EXPORT_SYMBOL(trace_print_hex_seq);
234 
235 const char *
236 trace_print_array_seq(struct trace_seq *p, const void *buf, int count,
237 		      size_t el_size)
238 {
239 	const char *ret = trace_seq_buffer_ptr(p);
240 	const char *prefix = "";
241 	void *ptr = (void *)buf;
242 	size_t buf_len = count * el_size;
243 
244 	trace_seq_putc(p, '{');
245 
246 	while (ptr < buf + buf_len) {
247 		switch (el_size) {
248 		case 1:
249 			trace_seq_printf(p, "%s0x%x", prefix,
250 					 *(u8 *)ptr);
251 			break;
252 		case 2:
253 			trace_seq_printf(p, "%s0x%x", prefix,
254 					 *(u16 *)ptr);
255 			break;
256 		case 4:
257 			trace_seq_printf(p, "%s0x%x", prefix,
258 					 *(u32 *)ptr);
259 			break;
260 		case 8:
261 			trace_seq_printf(p, "%s0x%llx", prefix,
262 					 *(u64 *)ptr);
263 			break;
264 		default:
265 			trace_seq_printf(p, "BAD SIZE:%zu 0x%x", el_size,
266 					 *(u8 *)ptr);
267 			el_size = 1;
268 		}
269 		prefix = ",";
270 		ptr += el_size;
271 	}
272 
273 	trace_seq_putc(p, '}');
274 	trace_seq_putc(p, 0);
275 
276 	return ret;
277 }
278 EXPORT_SYMBOL(trace_print_array_seq);
279 
280 const char *
281 trace_print_hex_dump_seq(struct trace_seq *p, const char *prefix_str,
282 			 int prefix_type, int rowsize, int groupsize,
283 			 const void *buf, size_t len, bool ascii)
284 {
285 	const char *ret = trace_seq_buffer_ptr(p);
286 
287 	trace_seq_putc(p, '\n');
288 	trace_seq_hex_dump(p, prefix_str, prefix_type,
289 			   rowsize, groupsize, buf, len, ascii);
290 	trace_seq_putc(p, 0);
291 	return ret;
292 }
293 EXPORT_SYMBOL(trace_print_hex_dump_seq);
294 
295 int trace_raw_output_prep(struct trace_iterator *iter,
296 			  struct trace_event *trace_event)
297 {
298 	struct trace_event_call *event;
299 	struct trace_seq *s = &iter->seq;
300 	struct trace_seq *p = &iter->tmp_seq;
301 	struct trace_entry *entry;
302 
303 	event = container_of(trace_event, struct trace_event_call, event);
304 	entry = iter->ent;
305 
306 	if (entry->type != event->event.type) {
307 		WARN_ON_ONCE(1);
308 		return TRACE_TYPE_UNHANDLED;
309 	}
310 
311 	trace_seq_init(p);
312 	trace_seq_printf(s, "%s: ", trace_event_name(event));
313 
314 	return trace_handle_return(s);
315 }
316 EXPORT_SYMBOL(trace_raw_output_prep);
317 
318 void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...)
319 {
320 	va_list ap;
321 
322 	va_start(ap, fmt);
323 	trace_check_vprintf(iter, trace_event_format(iter, fmt), ap);
324 	va_end(ap);
325 }
326 EXPORT_SYMBOL(trace_event_printf);
327 
328 static __printf(3, 0)
329 int trace_output_raw(struct trace_iterator *iter, char *name,
330 		     char *fmt, va_list ap)
331 {
332 	struct trace_seq *s = &iter->seq;
333 
334 	trace_seq_printf(s, "%s: ", name);
335 	trace_seq_vprintf(s, trace_event_format(iter, fmt), ap);
336 
337 	return trace_handle_return(s);
338 }
339 
340 int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...)
341 {
342 	va_list ap;
343 	int ret;
344 
345 	va_start(ap, fmt);
346 	ret = trace_output_raw(iter, name, fmt, ap);
347 	va_end(ap);
348 
349 	return ret;
350 }
351 EXPORT_SYMBOL_GPL(trace_output_call);
352 
353 static inline const char *kretprobed(const char *name, unsigned long addr)
354 {
355 	if (is_kretprobe_trampoline(addr))
356 		return "[unknown/kretprobe'd]";
357 	return name;
358 }
359 
360 void
361 trace_seq_print_sym(struct trace_seq *s, unsigned long address, bool offset)
362 {
363 #ifdef CONFIG_KALLSYMS
364 	char str[KSYM_SYMBOL_LEN];
365 	const char *name;
366 
367 	if (offset)
368 		sprint_symbol(str, address);
369 	else
370 		kallsyms_lookup(address, NULL, NULL, NULL, str);
371 	name = kretprobed(str, address);
372 
373 	if (name && strlen(name)) {
374 		trace_seq_puts(s, name);
375 		return;
376 	}
377 #endif
378 	trace_seq_printf(s, "0x%08lx", address);
379 }
380 
381 #ifndef CONFIG_64BIT
382 # define IP_FMT "%08lx"
383 #else
384 # define IP_FMT "%016lx"
385 #endif
386 
387 static int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
388 			     unsigned long ip, unsigned long sym_flags)
389 {
390 	struct file *file = NULL;
391 	unsigned long vmstart = 0;
392 	int ret = 1;
393 
394 	if (s->full)
395 		return 0;
396 
397 	if (mm) {
398 		const struct vm_area_struct *vma;
399 
400 		mmap_read_lock(mm);
401 		vma = find_vma(mm, ip);
402 		if (vma) {
403 			file = vma->vm_file;
404 			vmstart = vma->vm_start;
405 		}
406 		if (file) {
407 			ret = trace_seq_path(s, &file->f_path);
408 			if (ret)
409 				trace_seq_printf(s, "[+0x%lx]",
410 						 ip - vmstart);
411 		}
412 		mmap_read_unlock(mm);
413 	}
414 	if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
415 		trace_seq_printf(s, " <" IP_FMT ">", ip);
416 	return !trace_seq_has_overflowed(s);
417 }
418 
419 int
420 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
421 {
422 	if (!ip) {
423 		trace_seq_putc(s, '0');
424 		goto out;
425 	}
426 
427 	trace_seq_print_sym(s, ip, sym_flags & TRACE_ITER_SYM_OFFSET);
428 
429 	if (sym_flags & TRACE_ITER_SYM_ADDR)
430 		trace_seq_printf(s, " <" IP_FMT ">", ip);
431 
432  out:
433 	return !trace_seq_has_overflowed(s);
434 }
435 
436 /**
437  * trace_print_lat_fmt - print the irq, preempt and lockdep fields
438  * @s: trace seq struct to write to
439  * @entry: The trace entry field from the ring buffer
440  *
441  * Prints the generic fields of irqs off, in hard or softirq, preempt
442  * count.
443  */
444 int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
445 {
446 	char hardsoft_irq;
447 	char need_resched;
448 	char irqs_off;
449 	int hardirq;
450 	int softirq;
451 	int bh_off;
452 	int nmi;
453 
454 	nmi = entry->flags & TRACE_FLAG_NMI;
455 	hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
456 	softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
457 	bh_off = entry->flags & TRACE_FLAG_BH_OFF;
458 
459 	irqs_off =
460 		(entry->flags & TRACE_FLAG_IRQS_OFF && bh_off) ? 'D' :
461 		(entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
462 		bh_off ? 'b' :
463 		(entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' :
464 		'.';
465 
466 	switch (entry->flags & (TRACE_FLAG_NEED_RESCHED |
467 				TRACE_FLAG_PREEMPT_RESCHED)) {
468 	case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED:
469 		need_resched = 'N';
470 		break;
471 	case TRACE_FLAG_NEED_RESCHED:
472 		need_resched = 'n';
473 		break;
474 	case TRACE_FLAG_PREEMPT_RESCHED:
475 		need_resched = 'p';
476 		break;
477 	default:
478 		need_resched = '.';
479 		break;
480 	}
481 
482 	hardsoft_irq =
483 		(nmi && hardirq)     ? 'Z' :
484 		nmi                  ? 'z' :
485 		(hardirq && softirq) ? 'H' :
486 		hardirq              ? 'h' :
487 		softirq              ? 's' :
488 		                       '.' ;
489 
490 	trace_seq_printf(s, "%c%c%c",
491 			 irqs_off, need_resched, hardsoft_irq);
492 
493 	if (entry->preempt_count & 0xf)
494 		trace_seq_printf(s, "%x", entry->preempt_count & 0xf);
495 	else
496 		trace_seq_putc(s, '.');
497 
498 	if (entry->preempt_count & 0xf0)
499 		trace_seq_printf(s, "%x", entry->preempt_count >> 4);
500 	else
501 		trace_seq_putc(s, '.');
502 
503 	return !trace_seq_has_overflowed(s);
504 }
505 
506 static int
507 lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
508 {
509 	char comm[TASK_COMM_LEN];
510 
511 	trace_find_cmdline(entry->pid, comm);
512 
513 	trace_seq_printf(s, "%8.8s-%-7d %3d",
514 			 comm, entry->pid, cpu);
515 
516 	return trace_print_lat_fmt(s, entry);
517 }
518 
519 #undef MARK
520 #define MARK(v, s) {.val = v, .sym = s}
521 /* trace overhead mark */
522 static const struct trace_mark {
523 	unsigned long long	val; /* unit: nsec */
524 	char			sym;
525 } mark[] = {
526 	MARK(1000000000ULL	, '$'), /* 1 sec */
527 	MARK(100000000ULL	, '@'), /* 100 msec */
528 	MARK(10000000ULL	, '*'), /* 10 msec */
529 	MARK(1000000ULL		, '#'), /* 1000 usecs */
530 	MARK(100000ULL		, '!'), /* 100 usecs */
531 	MARK(10000ULL		, '+'), /* 10 usecs */
532 };
533 #undef MARK
534 
535 char trace_find_mark(unsigned long long d)
536 {
537 	int i;
538 	int size = ARRAY_SIZE(mark);
539 
540 	for (i = 0; i < size; i++) {
541 		if (d > mark[i].val)
542 			break;
543 	}
544 
545 	return (i == size) ? ' ' : mark[i].sym;
546 }
547 
548 static int
549 lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
550 {
551 	struct trace_array *tr = iter->tr;
552 	unsigned long verbose = tr->trace_flags & TRACE_ITER_VERBOSE;
553 	unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
554 	unsigned long long abs_ts = iter->ts - iter->array_buffer->time_start;
555 	unsigned long long rel_ts = next_ts - iter->ts;
556 	struct trace_seq *s = &iter->seq;
557 
558 	if (in_ns) {
559 		abs_ts = ns2usecs(abs_ts);
560 		rel_ts = ns2usecs(rel_ts);
561 	}
562 
563 	if (verbose && in_ns) {
564 		unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC);
565 		unsigned long abs_msec = (unsigned long)abs_ts;
566 		unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);
567 		unsigned long rel_msec = (unsigned long)rel_ts;
568 
569 		trace_seq_printf(
570 			s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
571 			ns2usecs(iter->ts),
572 			abs_msec, abs_usec,
573 			rel_msec, rel_usec);
574 
575 	} else if (verbose && !in_ns) {
576 		trace_seq_printf(
577 			s, "[%016llx] %lld (+%lld): ",
578 			iter->ts, abs_ts, rel_ts);
579 
580 	} else if (!verbose && in_ns) {
581 		trace_seq_printf(
582 			s, " %4lldus%c: ",
583 			abs_ts,
584 			trace_find_mark(rel_ts * NSEC_PER_USEC));
585 
586 	} else { /* !verbose && !in_ns */
587 		trace_seq_printf(s, " %4lld: ", abs_ts);
588 	}
589 
590 	return !trace_seq_has_overflowed(s);
591 }
592 
593 static void trace_print_time(struct trace_seq *s, struct trace_iterator *iter,
594 			     unsigned long long ts)
595 {
596 	unsigned long secs, usec_rem;
597 	unsigned long long t;
598 
599 	if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
600 		t = ns2usecs(ts);
601 		usec_rem = do_div(t, USEC_PER_SEC);
602 		secs = (unsigned long)t;
603 		trace_seq_printf(s, " %5lu.%06lu", secs, usec_rem);
604 	} else
605 		trace_seq_printf(s, " %12llu", ts);
606 }
607 
608 int trace_print_context(struct trace_iterator *iter)
609 {
610 	struct trace_array *tr = iter->tr;
611 	struct trace_seq *s = &iter->seq;
612 	struct trace_entry *entry = iter->ent;
613 	char comm[TASK_COMM_LEN];
614 
615 	trace_find_cmdline(entry->pid, comm);
616 
617 	trace_seq_printf(s, "%16s-%-7d ", comm, entry->pid);
618 
619 	if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
620 		unsigned int tgid = trace_find_tgid(entry->pid);
621 
622 		if (!tgid)
623 			trace_seq_printf(s, "(-------) ");
624 		else
625 			trace_seq_printf(s, "(%7d) ", tgid);
626 	}
627 
628 	trace_seq_printf(s, "[%03d] ", iter->cpu);
629 
630 	if (tr->trace_flags & TRACE_ITER_IRQ_INFO)
631 		trace_print_lat_fmt(s, entry);
632 
633 	trace_print_time(s, iter, iter->ts);
634 	trace_seq_puts(s, ": ");
635 
636 	return !trace_seq_has_overflowed(s);
637 }
638 
639 int trace_print_lat_context(struct trace_iterator *iter)
640 {
641 	struct trace_entry *entry, *next_entry;
642 	struct trace_array *tr = iter->tr;
643 	struct trace_seq *s = &iter->seq;
644 	unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE);
645 	u64 next_ts;
646 
647 	next_entry = trace_find_next_entry(iter, NULL, &next_ts);
648 	if (!next_entry)
649 		next_ts = iter->ts;
650 
651 	/* trace_find_next_entry() may change iter->ent */
652 	entry = iter->ent;
653 
654 	if (verbose) {
655 		char comm[TASK_COMM_LEN];
656 
657 		trace_find_cmdline(entry->pid, comm);
658 
659 		trace_seq_printf(
660 			s, "%16s %7d %3d %d %08x %08lx ",
661 			comm, entry->pid, iter->cpu, entry->flags,
662 			entry->preempt_count & 0xf, iter->idx);
663 	} else {
664 		lat_print_generic(s, entry, iter->cpu);
665 	}
666 
667 	lat_print_timestamp(iter, next_ts);
668 
669 	return !trace_seq_has_overflowed(s);
670 }
671 
672 /**
673  * ftrace_find_event - find a registered event
674  * @type: the type of event to look for
675  *
676  * Returns an event of type @type otherwise NULL
677  * Called with trace_event_read_lock() held.
678  */
679 struct trace_event *ftrace_find_event(int type)
680 {
681 	struct trace_event *event;
682 	unsigned key;
683 
684 	key = type & (EVENT_HASHSIZE - 1);
685 
686 	hlist_for_each_entry(event, &event_hash[key], node) {
687 		if (event->type == type)
688 			return event;
689 	}
690 
691 	return NULL;
692 }
693 
694 static DEFINE_IDA(trace_event_ida);
695 
696 static void free_trace_event_type(int type)
697 {
698 	if (type >= __TRACE_LAST_TYPE)
699 		ida_free(&trace_event_ida, type);
700 }
701 
702 static int alloc_trace_event_type(void)
703 {
704 	int next;
705 
706 	/* Skip static defined type numbers */
707 	next = ida_alloc_range(&trace_event_ida, __TRACE_LAST_TYPE,
708 			       TRACE_EVENT_TYPE_MAX, GFP_KERNEL);
709 	if (next < 0)
710 		return 0;
711 	return next;
712 }
713 
714 void trace_event_read_lock(void)
715 {
716 	down_read(&trace_event_sem);
717 }
718 
719 void trace_event_read_unlock(void)
720 {
721 	up_read(&trace_event_sem);
722 }
723 
724 /**
725  * register_trace_event - register output for an event type
726  * @event: the event type to register
727  *
728  * Event types are stored in a hash and this hash is used to
729  * find a way to print an event. If the @event->type is set
730  * then it will use that type, otherwise it will assign a
731  * type to use.
732  *
733  * If you assign your own type, please make sure it is added
734  * to the trace_type enum in trace.h, to avoid collisions
735  * with the dynamic types.
736  *
737  * Returns the event type number or zero on error.
738  */
739 int register_trace_event(struct trace_event *event)
740 {
741 	unsigned key;
742 	int ret = 0;
743 
744 	down_write(&trace_event_sem);
745 
746 	if (WARN_ON(!event))
747 		goto out;
748 
749 	if (WARN_ON(!event->funcs))
750 		goto out;
751 
752 	if (!event->type) {
753 		event->type = alloc_trace_event_type();
754 		if (!event->type)
755 			goto out;
756 	} else if (WARN(event->type > __TRACE_LAST_TYPE,
757 			"Need to add type to trace.h")) {
758 		goto out;
759 	} else {
760 		/* Is this event already used */
761 		if (ftrace_find_event(event->type))
762 			goto out;
763 	}
764 
765 	if (event->funcs->trace == NULL)
766 		event->funcs->trace = trace_nop_print;
767 	if (event->funcs->raw == NULL)
768 		event->funcs->raw = trace_nop_print;
769 	if (event->funcs->hex == NULL)
770 		event->funcs->hex = trace_nop_print;
771 	if (event->funcs->binary == NULL)
772 		event->funcs->binary = trace_nop_print;
773 
774 	key = event->type & (EVENT_HASHSIZE - 1);
775 
776 	hlist_add_head(&event->node, &event_hash[key]);
777 
778 	ret = event->type;
779  out:
780 	up_write(&trace_event_sem);
781 
782 	return ret;
783 }
784 EXPORT_SYMBOL_GPL(register_trace_event);
785 
786 /*
787  * Used by module code with the trace_event_sem held for write.
788  */
789 int __unregister_trace_event(struct trace_event *event)
790 {
791 	hlist_del(&event->node);
792 	free_trace_event_type(event->type);
793 	return 0;
794 }
795 
796 /**
797  * unregister_trace_event - remove a no longer used event
798  * @event: the event to remove
799  */
800 int unregister_trace_event(struct trace_event *event)
801 {
802 	down_write(&trace_event_sem);
803 	__unregister_trace_event(event);
804 	up_write(&trace_event_sem);
805 
806 	return 0;
807 }
808 EXPORT_SYMBOL_GPL(unregister_trace_event);
809 
810 /*
811  * Standard events
812  */
813 
814 static void print_array(struct trace_iterator *iter, void *pos,
815 			struct ftrace_event_field *field)
816 {
817 	int offset;
818 	int len;
819 	int i;
820 
821 	offset = *(int *)pos & 0xffff;
822 	len = *(int *)pos >> 16;
823 
824 	if (field)
825 		offset += field->offset + sizeof(int);
826 
827 	if (offset + len > iter->ent_size) {
828 		trace_seq_puts(&iter->seq, "<OVERFLOW>");
829 		return;
830 	}
831 
832 	pos = (void *)iter->ent + offset;
833 
834 	for (i = 0; i < len; i++, pos++) {
835 		if (i)
836 			trace_seq_putc(&iter->seq, ',');
837 		trace_seq_printf(&iter->seq, "%02x", *(unsigned char *)pos);
838 	}
839 }
840 
841 static void print_fields(struct trace_iterator *iter, struct trace_event_call *call,
842 			 struct list_head *head)
843 {
844 	struct ftrace_event_field *field;
845 	int offset;
846 	int len;
847 	int ret;
848 	void *pos;
849 
850 	list_for_each_entry_reverse(field, head, link) {
851 		trace_seq_printf(&iter->seq, " %s=", field->name);
852 		if (field->offset + field->size > iter->ent_size) {
853 			trace_seq_puts(&iter->seq, "<OVERFLOW>");
854 			continue;
855 		}
856 		pos = (void *)iter->ent + field->offset;
857 
858 		switch (field->filter_type) {
859 		case FILTER_COMM:
860 		case FILTER_STATIC_STRING:
861 			trace_seq_printf(&iter->seq, "%.*s", field->size, (char *)pos);
862 			break;
863 		case FILTER_RDYN_STRING:
864 		case FILTER_DYN_STRING:
865 			offset = *(int *)pos & 0xffff;
866 			len = *(int *)pos >> 16;
867 
868 			if (field->filter_type == FILTER_RDYN_STRING)
869 				offset += field->offset + sizeof(int);
870 
871 			if (offset + len > iter->ent_size) {
872 				trace_seq_puts(&iter->seq, "<OVERFLOW>");
873 				break;
874 			}
875 			pos = (void *)iter->ent + offset;
876 			trace_seq_printf(&iter->seq, "%.*s", len, (char *)pos);
877 			break;
878 		case FILTER_PTR_STRING:
879 			if (!iter->fmt_size)
880 				trace_iter_expand_format(iter);
881 			pos = *(void **)pos;
882 			ret = strncpy_from_kernel_nofault(iter->fmt, pos,
883 							  iter->fmt_size);
884 			if (ret < 0)
885 				trace_seq_printf(&iter->seq, "(0x%px)", pos);
886 			else
887 				trace_seq_printf(&iter->seq, "(0x%px:%s)",
888 						 pos, iter->fmt);
889 			break;
890 		case FILTER_TRACE_FN:
891 			pos = *(void **)pos;
892 			trace_seq_printf(&iter->seq, "%pS", pos);
893 			break;
894 		case FILTER_CPU:
895 		case FILTER_OTHER:
896 			switch (field->size) {
897 			case 1:
898 				if (isprint(*(char *)pos)) {
899 					trace_seq_printf(&iter->seq, "'%c'",
900 						 *(unsigned char *)pos);
901 				}
902 				trace_seq_printf(&iter->seq, "(%d)",
903 						 *(unsigned char *)pos);
904 				break;
905 			case 2:
906 				trace_seq_printf(&iter->seq, "0x%x (%d)",
907 						 *(unsigned short *)pos,
908 						 *(unsigned short *)pos);
909 				break;
910 			case 4:
911 				/* dynamic array info is 4 bytes */
912 				if (strstr(field->type, "__data_loc")) {
913 					print_array(iter, pos, NULL);
914 					break;
915 				}
916 
917 				if (strstr(field->type, "__rel_loc")) {
918 					print_array(iter, pos, field);
919 					break;
920 				}
921 
922 				trace_seq_printf(&iter->seq, "0x%x (%d)",
923 						 *(unsigned int *)pos,
924 						 *(unsigned int *)pos);
925 				break;
926 			case 8:
927 				trace_seq_printf(&iter->seq, "0x%llx (%lld)",
928 						 *(unsigned long long *)pos,
929 						 *(unsigned long long *)pos);
930 				break;
931 			default:
932 				trace_seq_puts(&iter->seq, "<INVALID-SIZE>");
933 				break;
934 			}
935 			break;
936 		default:
937 			trace_seq_puts(&iter->seq, "<INVALID-TYPE>");
938 		}
939 	}
940 	trace_seq_putc(&iter->seq, '\n');
941 }
942 
943 enum print_line_t print_event_fields(struct trace_iterator *iter,
944 				     struct trace_event *event)
945 {
946 	struct trace_event_call *call;
947 	struct list_head *head;
948 
949 	/* ftrace defined events have separate call structures */
950 	if (event->type <= __TRACE_LAST_TYPE) {
951 		bool found = false;
952 
953 		down_read(&trace_event_sem);
954 		list_for_each_entry(call, &ftrace_events, list) {
955 			if (call->event.type == event->type) {
956 				found = true;
957 				break;
958 			}
959 			/* No need to search all events */
960 			if (call->event.type > __TRACE_LAST_TYPE)
961 				break;
962 		}
963 		up_read(&trace_event_sem);
964 		if (!found) {
965 			trace_seq_printf(&iter->seq, "UNKNOWN TYPE %d\n", event->type);
966 			goto out;
967 		}
968 	} else {
969 		call = container_of(event, struct trace_event_call, event);
970 	}
971 	head = trace_get_fields(call);
972 
973 	trace_seq_printf(&iter->seq, "%s:", trace_event_name(call));
974 
975 	if (head && !list_empty(head))
976 		print_fields(iter, call, head);
977 	else
978 		trace_seq_puts(&iter->seq, "No fields found\n");
979 
980  out:
981 	return trace_handle_return(&iter->seq);
982 }
983 
984 enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,
985 				  struct trace_event *event)
986 {
987 	trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type);
988 
989 	return trace_handle_return(&iter->seq);
990 }
991 
992 static void print_fn_trace(struct trace_seq *s, unsigned long ip,
993 			   unsigned long parent_ip, int flags)
994 {
995 	seq_print_ip_sym(s, ip, flags);
996 
997 	if ((flags & TRACE_ITER_PRINT_PARENT) && parent_ip) {
998 		trace_seq_puts(s, " <-");
999 		seq_print_ip_sym(s, parent_ip, flags);
1000 	}
1001 }
1002 
1003 /* TRACE_FN */
1004 static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
1005 					struct trace_event *event)
1006 {
1007 	struct ftrace_entry *field;
1008 	struct trace_seq *s = &iter->seq;
1009 
1010 	trace_assign_type(field, iter->ent);
1011 
1012 	print_fn_trace(s, field->ip, field->parent_ip, flags);
1013 	trace_seq_putc(s, '\n');
1014 
1015 	return trace_handle_return(s);
1016 }
1017 
1018 static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
1019 				      struct trace_event *event)
1020 {
1021 	struct ftrace_entry *field;
1022 
1023 	trace_assign_type(field, iter->ent);
1024 
1025 	trace_seq_printf(&iter->seq, "%lx %lx\n",
1026 			 field->ip,
1027 			 field->parent_ip);
1028 
1029 	return trace_handle_return(&iter->seq);
1030 }
1031 
1032 static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
1033 				      struct trace_event *event)
1034 {
1035 	struct ftrace_entry *field;
1036 	struct trace_seq *s = &iter->seq;
1037 
1038 	trace_assign_type(field, iter->ent);
1039 
1040 	SEQ_PUT_HEX_FIELD(s, field->ip);
1041 	SEQ_PUT_HEX_FIELD(s, field->parent_ip);
1042 
1043 	return trace_handle_return(s);
1044 }
1045 
1046 static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
1047 				      struct trace_event *event)
1048 {
1049 	struct ftrace_entry *field;
1050 	struct trace_seq *s = &iter->seq;
1051 
1052 	trace_assign_type(field, iter->ent);
1053 
1054 	SEQ_PUT_FIELD(s, field->ip);
1055 	SEQ_PUT_FIELD(s, field->parent_ip);
1056 
1057 	return trace_handle_return(s);
1058 }
1059 
1060 static struct trace_event_functions trace_fn_funcs = {
1061 	.trace		= trace_fn_trace,
1062 	.raw		= trace_fn_raw,
1063 	.hex		= trace_fn_hex,
1064 	.binary		= trace_fn_bin,
1065 };
1066 
1067 static struct trace_event trace_fn_event = {
1068 	.type		= TRACE_FN,
1069 	.funcs		= &trace_fn_funcs,
1070 };
1071 
1072 /* TRACE_CTX an TRACE_WAKE */
1073 static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
1074 					     char *delim)
1075 {
1076 	struct ctx_switch_entry *field;
1077 	char comm[TASK_COMM_LEN];
1078 	int S, T;
1079 
1080 
1081 	trace_assign_type(field, iter->ent);
1082 
1083 	T = task_index_to_char(field->next_state);
1084 	S = task_index_to_char(field->prev_state);
1085 	trace_find_cmdline(field->next_pid, comm);
1086 	trace_seq_printf(&iter->seq,
1087 			 " %7d:%3d:%c %s [%03d] %7d:%3d:%c %s\n",
1088 			 field->prev_pid,
1089 			 field->prev_prio,
1090 			 S, delim,
1091 			 field->next_cpu,
1092 			 field->next_pid,
1093 			 field->next_prio,
1094 			 T, comm);
1095 
1096 	return trace_handle_return(&iter->seq);
1097 }
1098 
1099 static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,
1100 					 struct trace_event *event)
1101 {
1102 	return trace_ctxwake_print(iter, "==>");
1103 }
1104 
1105 static enum print_line_t trace_wake_print(struct trace_iterator *iter,
1106 					  int flags, struct trace_event *event)
1107 {
1108 	return trace_ctxwake_print(iter, "  +");
1109 }
1110 
1111 static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
1112 {
1113 	struct ctx_switch_entry *field;
1114 	int T;
1115 
1116 	trace_assign_type(field, iter->ent);
1117 
1118 	if (!S)
1119 		S = task_index_to_char(field->prev_state);
1120 	T = task_index_to_char(field->next_state);
1121 	trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
1122 			 field->prev_pid,
1123 			 field->prev_prio,
1124 			 S,
1125 			 field->next_cpu,
1126 			 field->next_pid,
1127 			 field->next_prio,
1128 			 T);
1129 
1130 	return trace_handle_return(&iter->seq);
1131 }
1132 
1133 static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,
1134 				       struct trace_event *event)
1135 {
1136 	return trace_ctxwake_raw(iter, 0);
1137 }
1138 
1139 static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags,
1140 					struct trace_event *event)
1141 {
1142 	return trace_ctxwake_raw(iter, '+');
1143 }
1144 
1145 
1146 static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
1147 {
1148 	struct ctx_switch_entry *field;
1149 	struct trace_seq *s = &iter->seq;
1150 	int T;
1151 
1152 	trace_assign_type(field, iter->ent);
1153 
1154 	if (!S)
1155 		S = task_index_to_char(field->prev_state);
1156 	T = task_index_to_char(field->next_state);
1157 
1158 	SEQ_PUT_HEX_FIELD(s, field->prev_pid);
1159 	SEQ_PUT_HEX_FIELD(s, field->prev_prio);
1160 	SEQ_PUT_HEX_FIELD(s, S);
1161 	SEQ_PUT_HEX_FIELD(s, field->next_cpu);
1162 	SEQ_PUT_HEX_FIELD(s, field->next_pid);
1163 	SEQ_PUT_HEX_FIELD(s, field->next_prio);
1164 	SEQ_PUT_HEX_FIELD(s, T);
1165 
1166 	return trace_handle_return(s);
1167 }
1168 
1169 static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,
1170 				       struct trace_event *event)
1171 {
1172 	return trace_ctxwake_hex(iter, 0);
1173 }
1174 
1175 static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags,
1176 					struct trace_event *event)
1177 {
1178 	return trace_ctxwake_hex(iter, '+');
1179 }
1180 
1181 static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
1182 					   int flags, struct trace_event *event)
1183 {
1184 	struct ctx_switch_entry *field;
1185 	struct trace_seq *s = &iter->seq;
1186 
1187 	trace_assign_type(field, iter->ent);
1188 
1189 	SEQ_PUT_FIELD(s, field->prev_pid);
1190 	SEQ_PUT_FIELD(s, field->prev_prio);
1191 	SEQ_PUT_FIELD(s, field->prev_state);
1192 	SEQ_PUT_FIELD(s, field->next_cpu);
1193 	SEQ_PUT_FIELD(s, field->next_pid);
1194 	SEQ_PUT_FIELD(s, field->next_prio);
1195 	SEQ_PUT_FIELD(s, field->next_state);
1196 
1197 	return trace_handle_return(s);
1198 }
1199 
1200 static struct trace_event_functions trace_ctx_funcs = {
1201 	.trace		= trace_ctx_print,
1202 	.raw		= trace_ctx_raw,
1203 	.hex		= trace_ctx_hex,
1204 	.binary		= trace_ctxwake_bin,
1205 };
1206 
1207 static struct trace_event trace_ctx_event = {
1208 	.type		= TRACE_CTX,
1209 	.funcs		= &trace_ctx_funcs,
1210 };
1211 
1212 static struct trace_event_functions trace_wake_funcs = {
1213 	.trace		= trace_wake_print,
1214 	.raw		= trace_wake_raw,
1215 	.hex		= trace_wake_hex,
1216 	.binary		= trace_ctxwake_bin,
1217 };
1218 
1219 static struct trace_event trace_wake_event = {
1220 	.type		= TRACE_WAKE,
1221 	.funcs		= &trace_wake_funcs,
1222 };
1223 
1224 /* TRACE_STACK */
1225 
1226 static enum print_line_t trace_stack_print(struct trace_iterator *iter,
1227 					   int flags, struct trace_event *event)
1228 {
1229 	struct stack_entry *field;
1230 	struct trace_seq *s = &iter->seq;
1231 	unsigned long *p;
1232 	unsigned long *end;
1233 
1234 	trace_assign_type(field, iter->ent);
1235 	end = (unsigned long *)((long)iter->ent + iter->ent_size);
1236 
1237 	trace_seq_puts(s, "<stack trace>\n");
1238 
1239 	for (p = field->caller; p && p < end && *p != ULONG_MAX; p++) {
1240 
1241 		if (trace_seq_has_overflowed(s))
1242 			break;
1243 
1244 		trace_seq_puts(s, " => ");
1245 		seq_print_ip_sym(s, *p, flags);
1246 		trace_seq_putc(s, '\n');
1247 	}
1248 
1249 	return trace_handle_return(s);
1250 }
1251 
1252 static struct trace_event_functions trace_stack_funcs = {
1253 	.trace		= trace_stack_print,
1254 };
1255 
1256 static struct trace_event trace_stack_event = {
1257 	.type		= TRACE_STACK,
1258 	.funcs		= &trace_stack_funcs,
1259 };
1260 
1261 /* TRACE_USER_STACK */
1262 static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
1263 						int flags, struct trace_event *event)
1264 {
1265 	struct trace_array *tr = iter->tr;
1266 	struct userstack_entry *field;
1267 	struct trace_seq *s = &iter->seq;
1268 	struct mm_struct *mm = NULL;
1269 	unsigned int i;
1270 
1271 	trace_assign_type(field, iter->ent);
1272 
1273 	trace_seq_puts(s, "<user stack trace>\n");
1274 
1275 	if (tr->trace_flags & TRACE_ITER_SYM_USEROBJ) {
1276 		struct task_struct *task;
1277 		/*
1278 		 * we do the lookup on the thread group leader,
1279 		 * since individual threads might have already quit!
1280 		 */
1281 		rcu_read_lock();
1282 		task = find_task_by_vpid(field->tgid);
1283 		if (task)
1284 			mm = get_task_mm(task);
1285 		rcu_read_unlock();
1286 	}
1287 
1288 	for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
1289 		unsigned long ip = field->caller[i];
1290 
1291 		if (!ip || trace_seq_has_overflowed(s))
1292 			break;
1293 
1294 		trace_seq_puts(s, " => ");
1295 		seq_print_user_ip(s, mm, ip, flags);
1296 		trace_seq_putc(s, '\n');
1297 	}
1298 
1299 	if (mm)
1300 		mmput(mm);
1301 
1302 	return trace_handle_return(s);
1303 }
1304 
1305 static struct trace_event_functions trace_user_stack_funcs = {
1306 	.trace		= trace_user_stack_print,
1307 };
1308 
1309 static struct trace_event trace_user_stack_event = {
1310 	.type		= TRACE_USER_STACK,
1311 	.funcs		= &trace_user_stack_funcs,
1312 };
1313 
1314 /* TRACE_HWLAT */
1315 static enum print_line_t
1316 trace_hwlat_print(struct trace_iterator *iter, int flags,
1317 		  struct trace_event *event)
1318 {
1319 	struct trace_entry *entry = iter->ent;
1320 	struct trace_seq *s = &iter->seq;
1321 	struct hwlat_entry *field;
1322 
1323 	trace_assign_type(field, entry);
1324 
1325 	trace_seq_printf(s, "#%-5u inner/outer(us): %4llu/%-5llu ts:%lld.%09ld count:%d",
1326 			 field->seqnum,
1327 			 field->duration,
1328 			 field->outer_duration,
1329 			 (long long)field->timestamp.tv_sec,
1330 			 field->timestamp.tv_nsec, field->count);
1331 
1332 	if (field->nmi_count) {
1333 		/*
1334 		 * The generic sched_clock() is not NMI safe, thus
1335 		 * we only record the count and not the time.
1336 		 */
1337 		if (!IS_ENABLED(CONFIG_GENERIC_SCHED_CLOCK))
1338 			trace_seq_printf(s, " nmi-total:%llu",
1339 					 field->nmi_total_ts);
1340 		trace_seq_printf(s, " nmi-count:%u",
1341 				 field->nmi_count);
1342 	}
1343 
1344 	trace_seq_putc(s, '\n');
1345 
1346 	return trace_handle_return(s);
1347 }
1348 
1349 static enum print_line_t
1350 trace_hwlat_raw(struct trace_iterator *iter, int flags,
1351 		struct trace_event *event)
1352 {
1353 	struct hwlat_entry *field;
1354 	struct trace_seq *s = &iter->seq;
1355 
1356 	trace_assign_type(field, iter->ent);
1357 
1358 	trace_seq_printf(s, "%llu %lld %lld %09ld %u\n",
1359 			 field->duration,
1360 			 field->outer_duration,
1361 			 (long long)field->timestamp.tv_sec,
1362 			 field->timestamp.tv_nsec,
1363 			 field->seqnum);
1364 
1365 	return trace_handle_return(s);
1366 }
1367 
1368 static struct trace_event_functions trace_hwlat_funcs = {
1369 	.trace		= trace_hwlat_print,
1370 	.raw		= trace_hwlat_raw,
1371 };
1372 
1373 static struct trace_event trace_hwlat_event = {
1374 	.type		= TRACE_HWLAT,
1375 	.funcs		= &trace_hwlat_funcs,
1376 };
1377 
1378 /* TRACE_OSNOISE */
1379 static enum print_line_t
1380 trace_osnoise_print(struct trace_iterator *iter, int flags,
1381 		    struct trace_event *event)
1382 {
1383 	struct trace_entry *entry = iter->ent;
1384 	struct trace_seq *s = &iter->seq;
1385 	struct osnoise_entry *field;
1386 	u64 ratio, ratio_dec;
1387 	u64 net_runtime;
1388 
1389 	trace_assign_type(field, entry);
1390 
1391 	/*
1392 	 * compute the available % of cpu time.
1393 	 */
1394 	net_runtime = field->runtime - field->noise;
1395 	ratio = net_runtime * 10000000;
1396 	do_div(ratio, field->runtime);
1397 	ratio_dec = do_div(ratio, 100000);
1398 
1399 	trace_seq_printf(s, "%llu %10llu %3llu.%05llu %7llu",
1400 			 field->runtime,
1401 			 field->noise,
1402 			 ratio, ratio_dec,
1403 			 field->max_sample);
1404 
1405 	trace_seq_printf(s, " %6u", field->hw_count);
1406 	trace_seq_printf(s, " %6u", field->nmi_count);
1407 	trace_seq_printf(s, " %6u", field->irq_count);
1408 	trace_seq_printf(s, " %6u", field->softirq_count);
1409 	trace_seq_printf(s, " %6u", field->thread_count);
1410 
1411 	trace_seq_putc(s, '\n');
1412 
1413 	return trace_handle_return(s);
1414 }
1415 
1416 static enum print_line_t
1417 trace_osnoise_raw(struct trace_iterator *iter, int flags,
1418 		  struct trace_event *event)
1419 {
1420 	struct osnoise_entry *field;
1421 	struct trace_seq *s = &iter->seq;
1422 
1423 	trace_assign_type(field, iter->ent);
1424 
1425 	trace_seq_printf(s, "%lld %llu %llu %u %u %u %u %u\n",
1426 			 field->runtime,
1427 			 field->noise,
1428 			 field->max_sample,
1429 			 field->hw_count,
1430 			 field->nmi_count,
1431 			 field->irq_count,
1432 			 field->softirq_count,
1433 			 field->thread_count);
1434 
1435 	return trace_handle_return(s);
1436 }
1437 
1438 static struct trace_event_functions trace_osnoise_funcs = {
1439 	.trace		= trace_osnoise_print,
1440 	.raw		= trace_osnoise_raw,
1441 };
1442 
1443 static struct trace_event trace_osnoise_event = {
1444 	.type		= TRACE_OSNOISE,
1445 	.funcs		= &trace_osnoise_funcs,
1446 };
1447 
1448 /* TRACE_TIMERLAT */
1449 
1450 static char *timerlat_lat_context[] = {"irq", "thread", "user-ret"};
1451 static enum print_line_t
1452 trace_timerlat_print(struct trace_iterator *iter, int flags,
1453 		     struct trace_event *event)
1454 {
1455 	struct trace_entry *entry = iter->ent;
1456 	struct trace_seq *s = &iter->seq;
1457 	struct timerlat_entry *field;
1458 
1459 	trace_assign_type(field, entry);
1460 
1461 	trace_seq_printf(s, "#%-5u context %6s timer_latency %9llu ns\n",
1462 			 field->seqnum,
1463 			 timerlat_lat_context[field->context],
1464 			 field->timer_latency);
1465 
1466 	return trace_handle_return(s);
1467 }
1468 
1469 static enum print_line_t
1470 trace_timerlat_raw(struct trace_iterator *iter, int flags,
1471 		   struct trace_event *event)
1472 {
1473 	struct timerlat_entry *field;
1474 	struct trace_seq *s = &iter->seq;
1475 
1476 	trace_assign_type(field, iter->ent);
1477 
1478 	trace_seq_printf(s, "%u %d %llu\n",
1479 			 field->seqnum,
1480 			 field->context,
1481 			 field->timer_latency);
1482 
1483 	return trace_handle_return(s);
1484 }
1485 
1486 static struct trace_event_functions trace_timerlat_funcs = {
1487 	.trace		= trace_timerlat_print,
1488 	.raw		= trace_timerlat_raw,
1489 };
1490 
1491 static struct trace_event trace_timerlat_event = {
1492 	.type		= TRACE_TIMERLAT,
1493 	.funcs		= &trace_timerlat_funcs,
1494 };
1495 
1496 /* TRACE_BPUTS */
1497 static enum print_line_t
1498 trace_bputs_print(struct trace_iterator *iter, int flags,
1499 		   struct trace_event *event)
1500 {
1501 	struct trace_entry *entry = iter->ent;
1502 	struct trace_seq *s = &iter->seq;
1503 	struct bputs_entry *field;
1504 
1505 	trace_assign_type(field, entry);
1506 
1507 	seq_print_ip_sym(s, field->ip, flags);
1508 	trace_seq_puts(s, ": ");
1509 	trace_seq_puts(s, field->str);
1510 
1511 	return trace_handle_return(s);
1512 }
1513 
1514 
1515 static enum print_line_t
1516 trace_bputs_raw(struct trace_iterator *iter, int flags,
1517 		struct trace_event *event)
1518 {
1519 	struct bputs_entry *field;
1520 	struct trace_seq *s = &iter->seq;
1521 
1522 	trace_assign_type(field, iter->ent);
1523 
1524 	trace_seq_printf(s, ": %lx : ", field->ip);
1525 	trace_seq_puts(s, field->str);
1526 
1527 	return trace_handle_return(s);
1528 }
1529 
1530 static struct trace_event_functions trace_bputs_funcs = {
1531 	.trace		= trace_bputs_print,
1532 	.raw		= trace_bputs_raw,
1533 };
1534 
1535 static struct trace_event trace_bputs_event = {
1536 	.type		= TRACE_BPUTS,
1537 	.funcs		= &trace_bputs_funcs,
1538 };
1539 
1540 /* TRACE_BPRINT */
1541 static enum print_line_t
1542 trace_bprint_print(struct trace_iterator *iter, int flags,
1543 		   struct trace_event *event)
1544 {
1545 	struct trace_entry *entry = iter->ent;
1546 	struct trace_seq *s = &iter->seq;
1547 	struct bprint_entry *field;
1548 
1549 	trace_assign_type(field, entry);
1550 
1551 	seq_print_ip_sym(s, field->ip, flags);
1552 	trace_seq_puts(s, ": ");
1553 	trace_seq_bprintf(s, field->fmt, field->buf);
1554 
1555 	return trace_handle_return(s);
1556 }
1557 
1558 
1559 static enum print_line_t
1560 trace_bprint_raw(struct trace_iterator *iter, int flags,
1561 		 struct trace_event *event)
1562 {
1563 	struct bprint_entry *field;
1564 	struct trace_seq *s = &iter->seq;
1565 
1566 	trace_assign_type(field, iter->ent);
1567 
1568 	trace_seq_printf(s, ": %lx : ", field->ip);
1569 	trace_seq_bprintf(s, field->fmt, field->buf);
1570 
1571 	return trace_handle_return(s);
1572 }
1573 
1574 static struct trace_event_functions trace_bprint_funcs = {
1575 	.trace		= trace_bprint_print,
1576 	.raw		= trace_bprint_raw,
1577 };
1578 
1579 static struct trace_event trace_bprint_event = {
1580 	.type		= TRACE_BPRINT,
1581 	.funcs		= &trace_bprint_funcs,
1582 };
1583 
1584 /* TRACE_PRINT */
1585 static enum print_line_t trace_print_print(struct trace_iterator *iter,
1586 					   int flags, struct trace_event *event)
1587 {
1588 	struct print_entry *field;
1589 	struct trace_seq *s = &iter->seq;
1590 	int max = iter->ent_size - offsetof(struct print_entry, buf);
1591 
1592 	trace_assign_type(field, iter->ent);
1593 
1594 	seq_print_ip_sym(s, field->ip, flags);
1595 	trace_seq_printf(s, ": %.*s", max, field->buf);
1596 
1597 	return trace_handle_return(s);
1598 }
1599 
1600 static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
1601 					 struct trace_event *event)
1602 {
1603 	struct print_entry *field;
1604 	int max = iter->ent_size - offsetof(struct print_entry, buf);
1605 
1606 	trace_assign_type(field, iter->ent);
1607 
1608 	trace_seq_printf(&iter->seq, "# %lx %.*s", field->ip, max, field->buf);
1609 
1610 	return trace_handle_return(&iter->seq);
1611 }
1612 
1613 static struct trace_event_functions trace_print_funcs = {
1614 	.trace		= trace_print_print,
1615 	.raw		= trace_print_raw,
1616 };
1617 
1618 static struct trace_event trace_print_event = {
1619 	.type	 	= TRACE_PRINT,
1620 	.funcs		= &trace_print_funcs,
1621 };
1622 
1623 static enum print_line_t trace_raw_data(struct trace_iterator *iter, int flags,
1624 					 struct trace_event *event)
1625 {
1626 	struct raw_data_entry *field;
1627 	int i;
1628 
1629 	trace_assign_type(field, iter->ent);
1630 
1631 	trace_seq_printf(&iter->seq, "# %x buf:", field->id);
1632 
1633 	for (i = 0; i < iter->ent_size - offsetof(struct raw_data_entry, buf); i++)
1634 		trace_seq_printf(&iter->seq, " %02x",
1635 				 (unsigned char)field->buf[i]);
1636 
1637 	trace_seq_putc(&iter->seq, '\n');
1638 
1639 	return trace_handle_return(&iter->seq);
1640 }
1641 
1642 static struct trace_event_functions trace_raw_data_funcs = {
1643 	.trace		= trace_raw_data,
1644 	.raw		= trace_raw_data,
1645 };
1646 
1647 static struct trace_event trace_raw_data_event = {
1648 	.type	 	= TRACE_RAW_DATA,
1649 	.funcs		= &trace_raw_data_funcs,
1650 };
1651 
1652 static enum print_line_t
1653 trace_func_repeats_raw(struct trace_iterator *iter, int flags,
1654 			 struct trace_event *event)
1655 {
1656 	struct func_repeats_entry *field;
1657 	struct trace_seq *s = &iter->seq;
1658 
1659 	trace_assign_type(field, iter->ent);
1660 
1661 	trace_seq_printf(s, "%lu %lu %u %llu\n",
1662 			 field->ip,
1663 			 field->parent_ip,
1664 			 field->count,
1665 			 FUNC_REPEATS_GET_DELTA_TS(field));
1666 
1667 	return trace_handle_return(s);
1668 }
1669 
1670 static enum print_line_t
1671 trace_func_repeats_print(struct trace_iterator *iter, int flags,
1672 			 struct trace_event *event)
1673 {
1674 	struct func_repeats_entry *field;
1675 	struct trace_seq *s = &iter->seq;
1676 
1677 	trace_assign_type(field, iter->ent);
1678 
1679 	print_fn_trace(s, field->ip, field->parent_ip, flags);
1680 	trace_seq_printf(s, " (repeats: %u, last_ts:", field->count);
1681 	trace_print_time(s, iter,
1682 			 iter->ts - FUNC_REPEATS_GET_DELTA_TS(field));
1683 	trace_seq_puts(s, ")\n");
1684 
1685 	return trace_handle_return(s);
1686 }
1687 
1688 static struct trace_event_functions trace_func_repeats_funcs = {
1689 	.trace		= trace_func_repeats_print,
1690 	.raw		= trace_func_repeats_raw,
1691 };
1692 
1693 static struct trace_event trace_func_repeats_event = {
1694 	.type	 	= TRACE_FUNC_REPEATS,
1695 	.funcs		= &trace_func_repeats_funcs,
1696 };
1697 
1698 static struct trace_event *events[] __initdata = {
1699 	&trace_fn_event,
1700 	&trace_ctx_event,
1701 	&trace_wake_event,
1702 	&trace_stack_event,
1703 	&trace_user_stack_event,
1704 	&trace_bputs_event,
1705 	&trace_bprint_event,
1706 	&trace_print_event,
1707 	&trace_hwlat_event,
1708 	&trace_osnoise_event,
1709 	&trace_timerlat_event,
1710 	&trace_raw_data_event,
1711 	&trace_func_repeats_event,
1712 	NULL
1713 };
1714 
1715 __init int init_events(void)
1716 {
1717 	struct trace_event *event;
1718 	int i, ret;
1719 
1720 	for (i = 0; events[i]; i++) {
1721 		event = events[i];
1722 		ret = register_trace_event(event);
1723 		WARN_ONCE(!ret, "event %d failed to register", event->type);
1724 	}
1725 
1726 	return 0;
1727 }
1728