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