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

source code of linux/kernel/trace/trace_output.c

Morty Proxy This is a proxified and sanitized view of the page, visit original site.