Branch data Line data Source code
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/sched/clock.h>
12 : : #include <linux/sched/mm.h>
13 : :
14 : : #include "trace_output.h"
15 : :
16 : : /* must be a power of 2 */
17 : : #define EVENT_HASHSIZE 128
18 : :
19 : : DECLARE_RWSEM(trace_event_sem);
20 : :
21 : : static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
22 : :
23 : : static int next_event_type = __TRACE_LAST_TYPE + 1;
24 : :
25 : 0 : enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter)
26 : : {
27 : 0 : struct trace_seq *s = &iter->seq;
28 : 0 : struct trace_entry *entry = iter->ent;
29 : 0 : struct bputs_entry *field;
30 : :
31 [ # # ]: 0 : trace_assign_type(field, entry);
32 : :
33 : 0 : trace_seq_puts(s, field->str);
34 : :
35 : 0 : return trace_handle_return(s);
36 : : }
37 : :
38 : 0 : enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
39 : : {
40 : 0 : struct trace_seq *s = &iter->seq;
41 : 0 : struct trace_entry *entry = iter->ent;
42 : 0 : struct bprint_entry *field;
43 : :
44 [ # # ]: 0 : trace_assign_type(field, entry);
45 : :
46 : 0 : trace_seq_bprintf(s, field->fmt, field->buf);
47 : :
48 : 0 : return trace_handle_return(s);
49 : : }
50 : :
51 : 0 : enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
52 : : {
53 : 0 : struct trace_seq *s = &iter->seq;
54 : 0 : struct trace_entry *entry = iter->ent;
55 : 0 : struct print_entry *field;
56 : :
57 [ # # ]: 0 : trace_assign_type(field, entry);
58 : :
59 : 0 : trace_seq_puts(s, field->buf);
60 : :
61 : 0 : return trace_handle_return(s);
62 : : }
63 : :
64 : : const char *
65 : 0 : 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 : 0 : unsigned long mask;
70 : 0 : const char *str;
71 : 0 : const char *ret = trace_seq_buffer_ptr(p);
72 : 0 : int i, first = 1;
73 : :
74 [ # # # # ]: 0 : for (i = 0; flag_array[i].name && flags; i++) {
75 : :
76 : 0 : mask = flag_array[i].mask;
77 [ # # ]: 0 : if ((flags & mask) != mask)
78 : 0 : continue;
79 : :
80 : 0 : str = flag_array[i].name;
81 : 0 : flags &= ~mask;
82 [ # # ]: 0 : if (!first && delim)
83 : 0 : trace_seq_puts(p, delim);
84 : : else
85 : : first = 0;
86 : 0 : trace_seq_puts(p, str);
87 : : }
88 : :
89 : : /* check for left over flags */
90 [ # # ]: 0 : if (flags) {
91 [ # # ]: 0 : if (!first && delim)
92 : 0 : trace_seq_puts(p, delim);
93 : 0 : trace_seq_printf(p, "0x%lx", flags);
94 : : }
95 : :
96 : 0 : trace_seq_putc(p, 0);
97 : :
98 : 0 : return ret;
99 : : }
100 : : EXPORT_SYMBOL(trace_print_flags_seq);
101 : :
102 : : const char *
103 : 0 : trace_print_symbols_seq(struct trace_seq *p, unsigned long val,
104 : : const struct trace_print_flags *symbol_array)
105 : : {
106 : 0 : int i;
107 : 0 : const char *ret = trace_seq_buffer_ptr(p);
108 : :
109 [ # # ]: 0 : for (i = 0; symbol_array[i].name; i++) {
110 : :
111 [ # # ]: 0 : if (val != symbol_array[i].mask)
112 : 0 : continue;
113 : :
114 : 0 : trace_seq_puts(p, symbol_array[i].name);
115 : 0 : break;
116 : : }
117 : :
118 [ # # ]: 0 : if (ret == (const char *)(trace_seq_buffer_ptr(p)))
119 : 0 : trace_seq_printf(p, "0x%lx", val);
120 : :
121 : 0 : trace_seq_putc(p, 0);
122 : :
123 : 0 : return ret;
124 : : }
125 : : EXPORT_SYMBOL(trace_print_symbols_seq);
126 : :
127 : : #if BITS_PER_LONG == 32
128 : : const char *
129 : : trace_print_flags_seq_u64(struct trace_seq *p, const char *delim,
130 : : unsigned long long flags,
131 : : const struct trace_print_flags_u64 *flag_array)
132 : : {
133 : : unsigned long long mask;
134 : : const char *str;
135 : : const char *ret = trace_seq_buffer_ptr(p);
136 : : int i, first = 1;
137 : :
138 : : for (i = 0; flag_array[i].name && flags; i++) {
139 : :
140 : : mask = flag_array[i].mask;
141 : : if ((flags & mask) != mask)
142 : : continue;
143 : :
144 : : str = flag_array[i].name;
145 : : flags &= ~mask;
146 : : if (!first && delim)
147 : : trace_seq_puts(p, delim);
148 : : else
149 : : first = 0;
150 : : trace_seq_puts(p, str);
151 : : }
152 : :
153 : : /* check for left over flags */
154 : : if (flags) {
155 : : if (!first && delim)
156 : : trace_seq_puts(p, delim);
157 : : trace_seq_printf(p, "0x%llx", flags);
158 : : }
159 : :
160 : : trace_seq_putc(p, 0);
161 : :
162 : : return ret;
163 : : }
164 : : EXPORT_SYMBOL(trace_print_flags_seq_u64);
165 : :
166 : : const char *
167 : : trace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val,
168 : : const struct trace_print_flags_u64 *symbol_array)
169 : : {
170 : : int i;
171 : : const char *ret = trace_seq_buffer_ptr(p);
172 : :
173 : : for (i = 0; symbol_array[i].name; i++) {
174 : :
175 : : if (val != symbol_array[i].mask)
176 : : continue;
177 : :
178 : : trace_seq_puts(p, symbol_array[i].name);
179 : : break;
180 : : }
181 : :
182 : : if (ret == (const char *)(trace_seq_buffer_ptr(p)))
183 : : trace_seq_printf(p, "0x%llx", val);
184 : :
185 : : trace_seq_putc(p, 0);
186 : :
187 : : return ret;
188 : : }
189 : : EXPORT_SYMBOL(trace_print_symbols_seq_u64);
190 : : #endif
191 : :
192 : : const char *
193 : 0 : trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
194 : : unsigned int bitmask_size)
195 : : {
196 : 0 : const char *ret = trace_seq_buffer_ptr(p);
197 : :
198 : 0 : trace_seq_bitmask(p, bitmask_ptr, bitmask_size * 8);
199 : 0 : trace_seq_putc(p, 0);
200 : :
201 : 0 : return ret;
202 : : }
203 : : EXPORT_SYMBOL_GPL(trace_print_bitmask_seq);
204 : :
205 : : /**
206 : : * trace_print_hex_seq - print buffer as hex sequence
207 : : * @p: trace seq struct to write to
208 : : * @buf: The buffer to print
209 : : * @buf_len: Length of @buf in bytes
210 : : * @concatenate: Print @buf as single hex string or with spacing
211 : : *
212 : : * Prints the passed buffer as a hex sequence either as a whole,
213 : : * single hex string if @concatenate is true or with spacing after
214 : : * each byte in case @concatenate is false.
215 : : */
216 : : const char *
217 : 0 : trace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len,
218 : : bool concatenate)
219 : : {
220 : 0 : int i;
221 [ # # ]: 0 : const char *ret = trace_seq_buffer_ptr(p);
222 [ # # ]: 0 : const char *fmt = concatenate ? "%*phN" : "%*ph";
223 : :
224 [ # # ]: 0 : for (i = 0; i < buf_len; i += 16)
225 : 0 : trace_seq_printf(p, fmt, min(buf_len - i, 16), &buf[i]);
226 : 0 : trace_seq_putc(p, 0);
227 : :
228 : 0 : return ret;
229 : : }
230 : : EXPORT_SYMBOL(trace_print_hex_seq);
231 : :
232 : : const char *
233 : 0 : trace_print_array_seq(struct trace_seq *p, const void *buf, int count,
234 : : size_t el_size)
235 : : {
236 : 0 : const char *ret = trace_seq_buffer_ptr(p);
237 : 0 : const char *prefix = "";
238 : 0 : void *ptr = (void *)buf;
239 : 0 : size_t buf_len = count * el_size;
240 : :
241 : 0 : trace_seq_putc(p, '{');
242 : :
243 [ # # ]: 0 : while (ptr < buf + buf_len) {
244 [ # # # # : 0 : switch (el_size) {
# ]
245 : 0 : case 1:
246 : 0 : trace_seq_printf(p, "%s0x%x", prefix,
247 : 0 : *(u8 *)ptr);
248 : 0 : break;
249 : 0 : case 2:
250 : 0 : trace_seq_printf(p, "%s0x%x", prefix,
251 : 0 : *(u16 *)ptr);
252 : 0 : break;
253 : 0 : case 4:
254 : 0 : trace_seq_printf(p, "%s0x%x", prefix,
255 : : *(u32 *)ptr);
256 : 0 : break;
257 : 0 : case 8:
258 : 0 : trace_seq_printf(p, "%s0x%llx", prefix,
259 : : *(u64 *)ptr);
260 : 0 : break;
261 : 0 : default:
262 : 0 : trace_seq_printf(p, "BAD SIZE:%zu 0x%x", el_size,
263 : 0 : *(u8 *)ptr);
264 : 0 : el_size = 1;
265 : : }
266 : 0 : prefix = ",";
267 : 0 : ptr += el_size;
268 : : }
269 : :
270 : 0 : trace_seq_putc(p, '}');
271 : 0 : trace_seq_putc(p, 0);
272 : :
273 : 0 : return ret;
274 : : }
275 : : EXPORT_SYMBOL(trace_print_array_seq);
276 : :
277 : : const char *
278 : 0 : trace_print_hex_dump_seq(struct trace_seq *p, const char *prefix_str,
279 : : int prefix_type, int rowsize, int groupsize,
280 : : const void *buf, size_t len, bool ascii)
281 : : {
282 : 0 : const char *ret = trace_seq_buffer_ptr(p);
283 : :
284 : 0 : trace_seq_putc(p, '\n');
285 : 0 : trace_seq_hex_dump(p, prefix_str, prefix_type,
286 : : rowsize, groupsize, buf, len, ascii);
287 : 0 : trace_seq_putc(p, 0);
288 : 0 : return ret;
289 : : }
290 : : EXPORT_SYMBOL(trace_print_hex_dump_seq);
291 : :
292 : 0 : int trace_raw_output_prep(struct trace_iterator *iter,
293 : : struct trace_event *trace_event)
294 : : {
295 : 0 : struct trace_event_call *event;
296 : 0 : struct trace_seq *s = &iter->seq;
297 : 0 : struct trace_seq *p = &iter->tmp_seq;
298 : 0 : struct trace_entry *entry;
299 : :
300 : 0 : event = container_of(trace_event, struct trace_event_call, event);
301 : 0 : entry = iter->ent;
302 : :
303 [ # # ]: 0 : if (entry->type != event->event.type) {
304 : 0 : WARN_ON_ONCE(1);
305 : 0 : return TRACE_TYPE_UNHANDLED;
306 : : }
307 : :
308 [ # # ]: 0 : trace_seq_init(p);
309 [ # # ]: 0 : trace_seq_printf(s, "%s: ", trace_event_name(event));
310 : :
311 : 0 : return trace_handle_return(s);
312 : : }
313 : : EXPORT_SYMBOL(trace_raw_output_prep);
314 : :
315 : 0 : static int trace_output_raw(struct trace_iterator *iter, char *name,
316 : : char *fmt, va_list ap)
317 : : {
318 : 0 : struct trace_seq *s = &iter->seq;
319 : :
320 : 0 : trace_seq_printf(s, "%s: ", name);
321 : 0 : trace_seq_vprintf(s, fmt, ap);
322 : :
323 : 0 : return trace_handle_return(s);
324 : : }
325 : :
326 : 0 : int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...)
327 : : {
328 : 0 : va_list ap;
329 : 0 : int ret;
330 : :
331 : 0 : va_start(ap, fmt);
332 : 0 : ret = trace_output_raw(iter, name, fmt, ap);
333 : 0 : va_end(ap);
334 : :
335 : 0 : return ret;
336 : : }
337 : : EXPORT_SYMBOL_GPL(trace_output_call);
338 : :
339 : : #ifdef CONFIG_KRETPROBES
340 : 0 : static inline const char *kretprobed(const char *name)
341 : : {
342 : 0 : static const char tramp_name[] = "kretprobe_trampoline";
343 : 0 : int size = sizeof(tramp_name);
344 : :
345 : 0 : if (strncmp(tramp_name, name, size) == 0)
346 : 0 : return "[unknown/kretprobe'd]";
347 : : return name;
348 : : }
349 : : #else
350 : : static inline const char *kretprobed(const char *name)
351 : : {
352 : : return name;
353 : : }
354 : : #endif /* CONFIG_KRETPROBES */
355 : :
356 : : static void
357 : 0 : seq_print_sym(struct trace_seq *s, unsigned long address, bool offset)
358 : : {
359 : : #ifdef CONFIG_KALLSYMS
360 : 0 : char str[KSYM_SYMBOL_LEN];
361 : 0 : const char *name;
362 : :
363 [ # # ]: 0 : if (offset)
364 : 0 : sprint_symbol(str, address);
365 : : else
366 : 0 : kallsyms_lookup(address, NULL, NULL, NULL, str);
367 [ # # ]: 0 : name = kretprobed(str);
368 : :
369 [ # # ]: 0 : if (name && strlen(name)) {
370 : 0 : trace_seq_puts(s, name);
371 : 0 : return;
372 : : }
373 : : #endif
374 : 0 : trace_seq_printf(s, "0x%08lx", address);
375 : : }
376 : :
377 : : #ifndef CONFIG_64BIT
378 : : # define IP_FMT "%08lx"
379 : : #else
380 : : # define IP_FMT "%016lx"
381 : : #endif
382 : :
383 : 0 : static int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
384 : : unsigned long ip, unsigned long sym_flags)
385 : : {
386 : 0 : struct file *file = NULL;
387 : 0 : unsigned long vmstart = 0;
388 : 0 : int ret = 1;
389 : :
390 [ # # ]: 0 : if (s->full)
391 : : return 0;
392 : :
393 [ # # ]: 0 : if (mm) {
394 : 0 : const struct vm_area_struct *vma;
395 : :
396 : 0 : down_read(&mm->mmap_sem);
397 : 0 : vma = find_vma(mm, ip);
398 [ # # ]: 0 : if (vma) {
399 : 0 : file = vma->vm_file;
400 : 0 : vmstart = vma->vm_start;
401 : : }
402 [ # # ]: 0 : if (file) {
403 : 0 : ret = trace_seq_path(s, &file->f_path);
404 [ # # ]: 0 : if (ret)
405 : 0 : trace_seq_printf(s, "[+0x%lx]",
406 : : ip - vmstart);
407 : : }
408 : 0 : up_read(&mm->mmap_sem);
409 : : }
410 [ # # # # : 0 : if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
# # ]
411 : 0 : trace_seq_printf(s, " <" IP_FMT ">", ip);
412 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
413 : : }
414 : :
415 : : int
416 : 0 : seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
417 : : {
418 [ # # ]: 0 : if (!ip) {
419 : 0 : trace_seq_putc(s, '0');
420 : 0 : goto out;
421 : : }
422 : :
423 : 0 : seq_print_sym(s, ip, sym_flags & TRACE_ITER_SYM_OFFSET);
424 : :
425 [ # # ]: 0 : if (sym_flags & TRACE_ITER_SYM_ADDR)
426 : 0 : trace_seq_printf(s, " <" IP_FMT ">", ip);
427 : :
428 : 0 : out:
429 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
430 : : }
431 : :
432 : : /**
433 : : * trace_print_lat_fmt - print the irq, preempt and lockdep fields
434 : : * @s: trace seq struct to write to
435 : : * @entry: The trace entry field from the ring buffer
436 : : *
437 : : * Prints the generic fields of irqs off, in hard or softirq, preempt
438 : : * count.
439 : : */
440 : 0 : int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry)
441 : : {
442 : 0 : char hardsoft_irq;
443 : 0 : char need_resched;
444 : 0 : char irqs_off;
445 : 0 : int hardirq;
446 : 0 : int softirq;
447 : 0 : int nmi;
448 : :
449 : 0 : nmi = entry->flags & TRACE_FLAG_NMI;
450 : 0 : hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
451 : 0 : softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
452 : :
453 [ # # # # ]: 0 : irqs_off =
454 : : (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
455 : : (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' :
456 : : '.';
457 : :
458 [ # # # # ]: 0 : switch (entry->flags & (TRACE_FLAG_NEED_RESCHED |
459 : : TRACE_FLAG_PREEMPT_RESCHED)) {
460 : : case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED:
461 : : need_resched = 'N';
462 : : break;
463 : 0 : case TRACE_FLAG_NEED_RESCHED:
464 : 0 : need_resched = 'n';
465 : 0 : break;
466 : 0 : case TRACE_FLAG_PREEMPT_RESCHED:
467 : 0 : need_resched = 'p';
468 : 0 : break;
469 : 0 : default:
470 : 0 : need_resched = '.';
471 : 0 : break;
472 : : }
473 : :
474 [ # # # # : 0 : hardsoft_irq =
# # ]
475 [ # # ]: 0 : (nmi && hardirq) ? 'Z' :
476 : : nmi ? 'z' :
477 [ # # ]: 0 : (hardirq && softirq) ? 'H' :
478 : : hardirq ? 'h' :
479 : : softirq ? 's' :
480 : : '.' ;
481 : :
482 : 0 : trace_seq_printf(s, "%c%c%c",
483 : : irqs_off, need_resched, hardsoft_irq);
484 : :
485 [ # # ]: 0 : if (entry->preempt_count)
486 : 0 : trace_seq_printf(s, "%x", entry->preempt_count);
487 : : else
488 : 0 : trace_seq_putc(s, '.');
489 : :
490 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
491 : : }
492 : :
493 : : static int
494 : 0 : lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
495 : : {
496 : 0 : char comm[TASK_COMM_LEN];
497 : :
498 : 0 : trace_find_cmdline(entry->pid, comm);
499 : :
500 : 0 : trace_seq_printf(s, "%8.8s-%-5d %3d",
501 : : comm, entry->pid, cpu);
502 : :
503 : 0 : return trace_print_lat_fmt(s, entry);
504 : : }
505 : :
506 : : #undef MARK
507 : : #define MARK(v, s) {.val = v, .sym = s}
508 : : /* trace overhead mark */
509 : : static const struct trace_mark {
510 : : unsigned long long val; /* unit: nsec */
511 : : char sym;
512 : : } mark[] = {
513 : : MARK(1000000000ULL , '$'), /* 1 sec */
514 : : MARK(100000000ULL , '@'), /* 100 msec */
515 : : MARK(10000000ULL , '*'), /* 10 msec */
516 : : MARK(1000000ULL , '#'), /* 1000 usecs */
517 : : MARK(100000ULL , '!'), /* 100 usecs */
518 : : MARK(10000ULL , '+'), /* 10 usecs */
519 : : };
520 : : #undef MARK
521 : :
522 : 0 : char trace_find_mark(unsigned long long d)
523 : : {
524 : 0 : int i;
525 : 0 : int size = ARRAY_SIZE(mark);
526 : :
527 [ # # # # ]: 0 : for (i = 0; i < size; i++) {
528 [ # # # # ]: 0 : if (d > mark[i].val)
529 : : break;
530 : : }
531 : :
532 [ # # # # ]: 0 : return (i == size) ? ' ' : mark[i].sym;
533 : : }
534 : :
535 : : static int
536 : 0 : lat_print_timestamp(struct trace_iterator *iter, u64 next_ts)
537 : : {
538 : 0 : struct trace_array *tr = iter->tr;
539 : 0 : unsigned long verbose = tr->trace_flags & TRACE_ITER_VERBOSE;
540 : 0 : unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS;
541 : 0 : unsigned long long abs_ts = iter->ts - iter->array_buffer->time_start;
542 : 0 : unsigned long long rel_ts = next_ts - iter->ts;
543 : 0 : struct trace_seq *s = &iter->seq;
544 : :
545 [ # # ]: 0 : if (in_ns) {
546 : 0 : abs_ts = ns2usecs(abs_ts);
547 : 0 : rel_ts = ns2usecs(rel_ts);
548 : : }
549 : :
550 [ # # ]: 0 : if (verbose && in_ns) {
551 : 0 : unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC);
552 : 0 : unsigned long abs_msec = (unsigned long)abs_ts;
553 : 0 : unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC);
554 : 0 : unsigned long rel_msec = (unsigned long)rel_ts;
555 : :
556 : 0 : trace_seq_printf(
557 : : s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ",
558 : : ns2usecs(iter->ts),
559 : : abs_msec, abs_usec,
560 : : rel_msec, rel_usec);
561 : :
562 [ # # ]: 0 : } else if (verbose && !in_ns) {
563 : 0 : trace_seq_printf(
564 : : s, "[%016llx] %lld (+%lld): ",
565 : : iter->ts, abs_ts, rel_ts);
566 : :
567 [ # # ]: 0 : } else if (!verbose && in_ns) {
568 : 0 : trace_seq_printf(
569 : : s, " %4lldus%c: ",
570 : : abs_ts,
571 : 0 : trace_find_mark(rel_ts * NSEC_PER_USEC));
572 : :
573 : : } else { /* !verbose && !in_ns */
574 : 0 : trace_seq_printf(s, " %4lld: ", abs_ts);
575 : : }
576 : :
577 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
578 : : }
579 : :
580 : 0 : int trace_print_context(struct trace_iterator *iter)
581 : : {
582 : 0 : struct trace_array *tr = iter->tr;
583 : 0 : struct trace_seq *s = &iter->seq;
584 : 0 : struct trace_entry *entry = iter->ent;
585 : 0 : unsigned long long t;
586 : 0 : unsigned long secs, usec_rem;
587 : 0 : char comm[TASK_COMM_LEN];
588 : :
589 : 0 : trace_find_cmdline(entry->pid, comm);
590 : :
591 : 0 : trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid);
592 : :
593 [ # # ]: 0 : if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
594 : 0 : unsigned int tgid = trace_find_tgid(entry->pid);
595 : :
596 [ # # ]: 0 : if (!tgid)
597 : 0 : trace_seq_printf(s, "(-----) ");
598 : : else
599 : 0 : trace_seq_printf(s, "(%5d) ", tgid);
600 : : }
601 : :
602 : 0 : trace_seq_printf(s, "[%03d] ", iter->cpu);
603 : :
604 [ # # ]: 0 : if (tr->trace_flags & TRACE_ITER_IRQ_INFO)
605 : 0 : trace_print_lat_fmt(s, entry);
606 : :
607 [ # # ]: 0 : if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) {
608 : 0 : t = ns2usecs(iter->ts);
609 : 0 : usec_rem = do_div(t, USEC_PER_SEC);
610 : 0 : secs = (unsigned long)t;
611 : 0 : trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem);
612 : : } else
613 : 0 : trace_seq_printf(s, " %12llu: ", iter->ts);
614 : :
615 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
616 : : }
617 : :
618 : 0 : int trace_print_lat_context(struct trace_iterator *iter)
619 : : {
620 : 0 : struct trace_array *tr = iter->tr;
621 : : /* trace_find_next_entry will reset ent_size */
622 : 0 : int ent_size = iter->ent_size;
623 : 0 : struct trace_seq *s = &iter->seq;
624 : 0 : u64 next_ts;
625 : 0 : struct trace_entry *entry = iter->ent,
626 : 0 : *next_entry = trace_find_next_entry(iter, NULL,
627 : : &next_ts);
628 : 0 : unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE);
629 : :
630 : : /* Restore the original ent_size */
631 : 0 : iter->ent_size = ent_size;
632 : :
633 [ # # ]: 0 : if (!next_entry)
634 : 0 : next_ts = iter->ts;
635 : :
636 [ # # ]: 0 : if (verbose) {
637 : 0 : char comm[TASK_COMM_LEN];
638 : :
639 : 0 : trace_find_cmdline(entry->pid, comm);
640 : :
641 : 0 : trace_seq_printf(
642 : : s, "%16s %5d %3d %d %08x %08lx ",
643 : 0 : comm, entry->pid, iter->cpu, entry->flags,
644 : 0 : entry->preempt_count, iter->idx);
645 : : } else {
646 : 0 : lat_print_generic(s, entry, iter->cpu);
647 : : }
648 : :
649 : 0 : lat_print_timestamp(iter, next_ts);
650 : :
651 [ # # ]: 0 : return !trace_seq_has_overflowed(s);
652 : : }
653 : :
654 : : /**
655 : : * ftrace_find_event - find a registered event
656 : : * @type: the type of event to look for
657 : : *
658 : : * Returns an event of type @type otherwise NULL
659 : : * Called with trace_event_read_lock() held.
660 : : */
661 : 13530 : struct trace_event *ftrace_find_event(int type)
662 : : {
663 : 13530 : struct trace_event *event;
664 : 13530 : unsigned key;
665 : :
666 : 13530 : key = type & (EVENT_HASHSIZE - 1);
667 : :
668 [ + + + + : 71940 : hlist_for_each_entry(event, &event_hash[key], node) {
+ + + - -
- - - -
- ]
669 [ + - + - : 58410 : if (event->type == type)
- - ]
670 : 0 : return event;
671 : : }
672 : :
673 : : return NULL;
674 : : }
675 : :
676 : : static LIST_HEAD(ftrace_event_list);
677 : :
678 : 0 : static int trace_search_list(struct list_head **list)
679 : : {
680 : 0 : struct trace_event *e;
681 : 0 : int last = __TRACE_LAST_TYPE;
682 : :
683 : 0 : if (list_empty(&ftrace_event_list)) {
684 : : *list = &ftrace_event_list;
685 : : return last + 1;
686 : : }
687 : :
688 : : /*
689 : : * We used up all possible max events,
690 : : * lets see if somebody freed one.
691 : : */
692 [ # # ]: 0 : list_for_each_entry(e, &ftrace_event_list, list) {
693 [ # # ]: 0 : if (e->type != last + 1)
694 : : break;
695 : 0 : last++;
696 : : }
697 : :
698 : : /* Did we used up all 65 thousand events??? */
699 [ # # ]: 0 : if ((last + 1) > TRACE_EVENT_TYPE_MAX)
700 : : return 0;
701 : :
702 : 0 : *list = &e->list;
703 : 0 : return last + 1;
704 : : }
705 : :
706 : 0 : void trace_event_read_lock(void)
707 : : {
708 : 0 : down_read(&trace_event_sem);
709 : 0 : }
710 : :
711 : 0 : void trace_event_read_unlock(void)
712 : : {
713 : 0 : up_read(&trace_event_sem);
714 : 0 : }
715 : :
716 : : /**
717 : : * register_trace_event - register output for an event type
718 : : * @event: the event type to register
719 : : *
720 : : * Event types are stored in a hash and this hash is used to
721 : : * find a way to print an event. If the @event->type is set
722 : : * then it will use that type, otherwise it will assign a
723 : : * type to use.
724 : : *
725 : : * If you assign your own type, please make sure it is added
726 : : * to the trace_type enum in trace.h, to avoid collisions
727 : : * with the dynamic types.
728 : : *
729 : : * Returns the event type number or zero on error.
730 : : */
731 : 13530 : int register_trace_event(struct trace_event *event)
732 : : {
733 : 13530 : unsigned key;
734 : 13530 : int ret = 0;
735 : :
736 : 13530 : down_write(&trace_event_sem);
737 : :
738 [ - + - + ]: 13530 : if (WARN_ON(!event))
739 : 0 : goto out;
740 : :
741 [ - + - + ]: 13530 : if (WARN_ON(!event->funcs))
742 : 0 : goto out;
743 : :
744 [ + + ]: 13530 : INIT_LIST_HEAD(&event->list);
745 : :
746 [ + + ]: 13530 : if (!event->type) {
747 : 13409 : struct list_head *list = NULL;
748 : :
749 [ - + ]: 13409 : if (next_event_type > TRACE_EVENT_TYPE_MAX) {
750 : :
751 [ # # ]: 0 : event->type = trace_search_list(&list);
752 [ # # ]: 0 : if (!event->type)
753 : 0 : goto out;
754 : :
755 : : } else {
756 : :
757 : 13409 : event->type = next_event_type++;
758 : 13409 : list = &ftrace_event_list;
759 : : }
760 : :
761 [ + + - + : 26818 : if (WARN_ON(ftrace_find_event(event->type)))
- + ]
762 : 0 : goto out;
763 : :
764 : 13409 : list_add_tail(&event->list, list);
765 : :
766 [ - + ]: 121 : } else if (event->type > __TRACE_LAST_TYPE) {
767 : 0 : printk(KERN_WARNING "Need to add type to trace.h\n");
768 : 0 : WARN_ON(1);
769 : 0 : goto out;
770 : : } else {
771 : : /* Is this event already used */
772 [ - + - + ]: 242 : if (ftrace_find_event(event->type))
773 : 0 : goto out;
774 : : }
775 : :
776 [ - + ]: 13530 : if (event->funcs->trace == NULL)
777 : 0 : event->funcs->trace = trace_nop_print;
778 [ + + ]: 13530 : if (event->funcs->raw == NULL)
779 : 8723 : event->funcs->raw = trace_nop_print;
780 [ + + ]: 13530 : if (event->funcs->hex == NULL)
781 : 8778 : event->funcs->hex = trace_nop_print;
782 [ + + ]: 13530 : if (event->funcs->binary == NULL)
783 : 8767 : event->funcs->binary = trace_nop_print;
784 : :
785 : 13530 : key = event->type & (EVENT_HASHSIZE - 1);
786 : :
787 [ + + ]: 13530 : hlist_add_head(&event->node, &event_hash[key]);
788 : :
789 : 13530 : ret = event->type;
790 : 13530 : out:
791 : 13530 : up_write(&trace_event_sem);
792 : :
793 : 13530 : return ret;
794 : : }
795 : : EXPORT_SYMBOL_GPL(register_trace_event);
796 : :
797 : : /*
798 : : * Used by module code with the trace_event_sem held for write.
799 : : */
800 : 0 : int __unregister_trace_event(struct trace_event *event)
801 : : {
802 [ # # ]: 0 : hlist_del(&event->node);
803 : 0 : list_del(&event->list);
804 : 0 : return 0;
805 : : }
806 : :
807 : : /**
808 : : * unregister_trace_event - remove a no longer used event
809 : : * @event: the event to remove
810 : : */
811 : 0 : int unregister_trace_event(struct trace_event *event)
812 : : {
813 : 0 : down_write(&trace_event_sem);
814 [ # # ]: 0 : __unregister_trace_event(event);
815 : 0 : up_write(&trace_event_sem);
816 : :
817 : 0 : return 0;
818 : : }
819 : : EXPORT_SYMBOL_GPL(unregister_trace_event);
820 : :
821 : : /*
822 : : * Standard events
823 : : */
824 : :
825 : 0 : enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags,
826 : : struct trace_event *event)
827 : : {
828 : 0 : trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type);
829 : :
830 : 0 : return trace_handle_return(&iter->seq);
831 : : }
832 : :
833 : : /* TRACE_FN */
834 : 0 : static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags,
835 : : struct trace_event *event)
836 : : {
837 : 0 : struct ftrace_entry *field;
838 : 0 : struct trace_seq *s = &iter->seq;
839 : :
840 [ # # ]: 0 : trace_assign_type(field, iter->ent);
841 : :
842 : 0 : seq_print_ip_sym(s, field->ip, flags);
843 : :
844 [ # # # # ]: 0 : if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
845 : 0 : trace_seq_puts(s, " <-");
846 : 0 : seq_print_ip_sym(s, field->parent_ip, flags);
847 : : }
848 : :
849 : 0 : trace_seq_putc(s, '\n');
850 : :
851 : 0 : return trace_handle_return(s);
852 : : }
853 : :
854 : 0 : static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags,
855 : : struct trace_event *event)
856 : : {
857 : 0 : struct ftrace_entry *field;
858 : :
859 [ # # ]: 0 : trace_assign_type(field, iter->ent);
860 : :
861 : 0 : trace_seq_printf(&iter->seq, "%lx %lx\n",
862 : : field->ip,
863 : : field->parent_ip);
864 : :
865 : 0 : return trace_handle_return(&iter->seq);
866 : : }
867 : :
868 : 0 : static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags,
869 : : struct trace_event *event)
870 : : {
871 : 0 : struct ftrace_entry *field;
872 : 0 : struct trace_seq *s = &iter->seq;
873 : :
874 [ # # ]: 0 : trace_assign_type(field, iter->ent);
875 : :
876 : 0 : SEQ_PUT_HEX_FIELD(s, field->ip);
877 : 0 : SEQ_PUT_HEX_FIELD(s, field->parent_ip);
878 : :
879 : 0 : return trace_handle_return(s);
880 : : }
881 : :
882 : 0 : static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags,
883 : : struct trace_event *event)
884 : : {
885 : 0 : struct ftrace_entry *field;
886 : 0 : struct trace_seq *s = &iter->seq;
887 : :
888 [ # # ]: 0 : trace_assign_type(field, iter->ent);
889 : :
890 : 0 : SEQ_PUT_FIELD(s, field->ip);
891 : 0 : SEQ_PUT_FIELD(s, field->parent_ip);
892 : :
893 : 0 : return trace_handle_return(s);
894 : : }
895 : :
896 : : static struct trace_event_functions trace_fn_funcs = {
897 : : .trace = trace_fn_trace,
898 : : .raw = trace_fn_raw,
899 : : .hex = trace_fn_hex,
900 : : .binary = trace_fn_bin,
901 : : };
902 : :
903 : : static struct trace_event trace_fn_event = {
904 : : .type = TRACE_FN,
905 : : .funcs = &trace_fn_funcs,
906 : : };
907 : :
908 : : /* TRACE_CTX an TRACE_WAKE */
909 : 0 : static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
910 : : char *delim)
911 : : {
912 : 0 : struct ctx_switch_entry *field;
913 : 0 : char comm[TASK_COMM_LEN];
914 : 0 : int S, T;
915 : :
916 : :
917 : 0 : trace_assign_type(field, iter->ent);
918 : :
919 : 0 : T = task_index_to_char(field->next_state);
920 : 0 : S = task_index_to_char(field->prev_state);
921 : 0 : trace_find_cmdline(field->next_pid, comm);
922 : 0 : trace_seq_printf(&iter->seq,
923 : : " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
924 : : field->prev_pid,
925 : 0 : field->prev_prio,
926 : : S, delim,
927 : : field->next_cpu,
928 : : field->next_pid,
929 : 0 : field->next_prio,
930 : : T, comm);
931 : :
932 : 0 : return trace_handle_return(&iter->seq);
933 : : }
934 : :
935 : 0 : static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags,
936 : : struct trace_event *event)
937 : : {
938 : 0 : return trace_ctxwake_print(iter, "==>");
939 : : }
940 : :
941 : 0 : static enum print_line_t trace_wake_print(struct trace_iterator *iter,
942 : : int flags, struct trace_event *event)
943 : : {
944 : 0 : return trace_ctxwake_print(iter, " +");
945 : : }
946 : :
947 : 0 : static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
948 : : {
949 : 0 : struct ctx_switch_entry *field;
950 : 0 : int T;
951 : :
952 : 0 : trace_assign_type(field, iter->ent);
953 : :
954 [ # # ]: 0 : if (!S)
955 : 0 : S = task_index_to_char(field->prev_state);
956 : 0 : T = task_index_to_char(field->next_state);
957 : 0 : trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
958 : : field->prev_pid,
959 : 0 : field->prev_prio,
960 : : S,
961 : : field->next_cpu,
962 : : field->next_pid,
963 : 0 : field->next_prio,
964 : : T);
965 : :
966 : 0 : return trace_handle_return(&iter->seq);
967 : : }
968 : :
969 : 0 : static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags,
970 : : struct trace_event *event)
971 : : {
972 : 0 : return trace_ctxwake_raw(iter, 0);
973 : : }
974 : :
975 : 0 : static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags,
976 : : struct trace_event *event)
977 : : {
978 : 0 : return trace_ctxwake_raw(iter, '+');
979 : : }
980 : :
981 : :
982 : 0 : static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
983 : : {
984 : 0 : struct ctx_switch_entry *field;
985 : 0 : struct trace_seq *s = &iter->seq;
986 : 0 : int T;
987 : :
988 : 0 : trace_assign_type(field, iter->ent);
989 : :
990 [ # # ]: 0 : if (!S)
991 : 0 : S = task_index_to_char(field->prev_state);
992 : 0 : T = task_index_to_char(field->next_state);
993 : :
994 : 0 : SEQ_PUT_HEX_FIELD(s, field->prev_pid);
995 : 0 : SEQ_PUT_HEX_FIELD(s, field->prev_prio);
996 : 0 : SEQ_PUT_HEX_FIELD(s, S);
997 : 0 : SEQ_PUT_HEX_FIELD(s, field->next_cpu);
998 : 0 : SEQ_PUT_HEX_FIELD(s, field->next_pid);
999 : 0 : SEQ_PUT_HEX_FIELD(s, field->next_prio);
1000 : 0 : SEQ_PUT_HEX_FIELD(s, T);
1001 : :
1002 : 0 : return trace_handle_return(s);
1003 : : }
1004 : :
1005 : 0 : static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags,
1006 : : struct trace_event *event)
1007 : : {
1008 : 0 : return trace_ctxwake_hex(iter, 0);
1009 : : }
1010 : :
1011 : 0 : static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags,
1012 : : struct trace_event *event)
1013 : : {
1014 : 0 : return trace_ctxwake_hex(iter, '+');
1015 : : }
1016 : :
1017 : 0 : static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
1018 : : int flags, struct trace_event *event)
1019 : : {
1020 : 0 : struct ctx_switch_entry *field;
1021 : 0 : struct trace_seq *s = &iter->seq;
1022 : :
1023 : 0 : trace_assign_type(field, iter->ent);
1024 : :
1025 : 0 : SEQ_PUT_FIELD(s, field->prev_pid);
1026 : 0 : SEQ_PUT_FIELD(s, field->prev_prio);
1027 : 0 : SEQ_PUT_FIELD(s, field->prev_state);
1028 : 0 : SEQ_PUT_FIELD(s, field->next_cpu);
1029 : 0 : SEQ_PUT_FIELD(s, field->next_pid);
1030 : 0 : SEQ_PUT_FIELD(s, field->next_prio);
1031 : 0 : SEQ_PUT_FIELD(s, field->next_state);
1032 : :
1033 : 0 : return trace_handle_return(s);
1034 : : }
1035 : :
1036 : : static struct trace_event_functions trace_ctx_funcs = {
1037 : : .trace = trace_ctx_print,
1038 : : .raw = trace_ctx_raw,
1039 : : .hex = trace_ctx_hex,
1040 : : .binary = trace_ctxwake_bin,
1041 : : };
1042 : :
1043 : : static struct trace_event trace_ctx_event = {
1044 : : .type = TRACE_CTX,
1045 : : .funcs = &trace_ctx_funcs,
1046 : : };
1047 : :
1048 : : static struct trace_event_functions trace_wake_funcs = {
1049 : : .trace = trace_wake_print,
1050 : : .raw = trace_wake_raw,
1051 : : .hex = trace_wake_hex,
1052 : : .binary = trace_ctxwake_bin,
1053 : : };
1054 : :
1055 : : static struct trace_event trace_wake_event = {
1056 : : .type = TRACE_WAKE,
1057 : : .funcs = &trace_wake_funcs,
1058 : : };
1059 : :
1060 : : /* TRACE_STACK */
1061 : :
1062 : 0 : static enum print_line_t trace_stack_print(struct trace_iterator *iter,
1063 : : int flags, struct trace_event *event)
1064 : : {
1065 : 0 : struct stack_entry *field;
1066 : 0 : struct trace_seq *s = &iter->seq;
1067 : 0 : unsigned long *p;
1068 : 0 : unsigned long *end;
1069 : :
1070 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1071 : 0 : end = (unsigned long *)((long)iter->ent + iter->ent_size);
1072 : :
1073 : 0 : trace_seq_puts(s, "<stack trace>\n");
1074 : :
1075 [ # # # # ]: 0 : for (p = field->caller; p && p < end && *p != ULONG_MAX; p++) {
1076 : :
1077 [ # # # # ]: 0 : if (trace_seq_has_overflowed(s))
1078 : : break;
1079 : :
1080 : 0 : trace_seq_puts(s, " => ");
1081 : 0 : seq_print_ip_sym(s, *p, flags);
1082 : 0 : trace_seq_putc(s, '\n');
1083 : : }
1084 : :
1085 : 0 : return trace_handle_return(s);
1086 : : }
1087 : :
1088 : : static struct trace_event_functions trace_stack_funcs = {
1089 : : .trace = trace_stack_print,
1090 : : };
1091 : :
1092 : : static struct trace_event trace_stack_event = {
1093 : : .type = TRACE_STACK,
1094 : : .funcs = &trace_stack_funcs,
1095 : : };
1096 : :
1097 : : /* TRACE_USER_STACK */
1098 : 0 : static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
1099 : : int flags, struct trace_event *event)
1100 : : {
1101 : 0 : struct trace_array *tr = iter->tr;
1102 : 0 : struct userstack_entry *field;
1103 : 0 : struct trace_seq *s = &iter->seq;
1104 : 0 : struct mm_struct *mm = NULL;
1105 : 0 : unsigned int i;
1106 : :
1107 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1108 : :
1109 : 0 : trace_seq_puts(s, "<user stack trace>\n");
1110 : :
1111 [ # # ]: 0 : if (tr->trace_flags & TRACE_ITER_SYM_USEROBJ) {
1112 : 0 : struct task_struct *task;
1113 : : /*
1114 : : * we do the lookup on the thread group leader,
1115 : : * since individual threads might have already quit!
1116 : : */
1117 : 0 : rcu_read_lock();
1118 : 0 : task = find_task_by_vpid(field->tgid);
1119 [ # # ]: 0 : if (task)
1120 : 0 : mm = get_task_mm(task);
1121 : 0 : rcu_read_unlock();
1122 : : }
1123 : :
1124 [ # # ]: 0 : for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
1125 : 0 : unsigned long ip = field->caller[i];
1126 : :
1127 [ # # # # ]: 0 : if (!ip || trace_seq_has_overflowed(s))
1128 : : break;
1129 : :
1130 : 0 : trace_seq_puts(s, " => ");
1131 : 0 : seq_print_user_ip(s, mm, ip, flags);
1132 : 0 : trace_seq_putc(s, '\n');
1133 : : }
1134 : :
1135 [ # # ]: 0 : if (mm)
1136 : 0 : mmput(mm);
1137 : :
1138 : 0 : return trace_handle_return(s);
1139 : : }
1140 : :
1141 : : static struct trace_event_functions trace_user_stack_funcs = {
1142 : : .trace = trace_user_stack_print,
1143 : : };
1144 : :
1145 : : static struct trace_event trace_user_stack_event = {
1146 : : .type = TRACE_USER_STACK,
1147 : : .funcs = &trace_user_stack_funcs,
1148 : : };
1149 : :
1150 : : /* TRACE_HWLAT */
1151 : : static enum print_line_t
1152 : 0 : trace_hwlat_print(struct trace_iterator *iter, int flags,
1153 : : struct trace_event *event)
1154 : : {
1155 : 0 : struct trace_entry *entry = iter->ent;
1156 : 0 : struct trace_seq *s = &iter->seq;
1157 : 0 : struct hwlat_entry *field;
1158 : :
1159 [ # # ]: 0 : trace_assign_type(field, entry);
1160 : :
1161 : 0 : trace_seq_printf(s, "#%-5u inner/outer(us): %4llu/%-5llu ts:%lld.%09ld",
1162 : : field->seqnum,
1163 : : field->duration,
1164 : : field->outer_duration,
1165 : 0 : (long long)field->timestamp.tv_sec,
1166 : : field->timestamp.tv_nsec);
1167 : :
1168 [ # # ]: 0 : if (field->nmi_count) {
1169 : : /*
1170 : : * The generic sched_clock() is not NMI safe, thus
1171 : : * we only record the count and not the time.
1172 : : */
1173 : 0 : if (!IS_ENABLED(CONFIG_GENERIC_SCHED_CLOCK))
1174 : 0 : trace_seq_printf(s, " nmi-total:%llu",
1175 : : field->nmi_total_ts);
1176 : 0 : trace_seq_printf(s, " nmi-count:%u",
1177 : : field->nmi_count);
1178 : : }
1179 : :
1180 : 0 : trace_seq_putc(s, '\n');
1181 : :
1182 : 0 : return trace_handle_return(s);
1183 : : }
1184 : :
1185 : :
1186 : : static enum print_line_t
1187 : 0 : trace_hwlat_raw(struct trace_iterator *iter, int flags,
1188 : : struct trace_event *event)
1189 : : {
1190 : 0 : struct hwlat_entry *field;
1191 : 0 : struct trace_seq *s = &iter->seq;
1192 : :
1193 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1194 : :
1195 : 0 : trace_seq_printf(s, "%llu %lld %lld %09ld %u\n",
1196 : : field->duration,
1197 : : field->outer_duration,
1198 : 0 : (long long)field->timestamp.tv_sec,
1199 : : field->timestamp.tv_nsec,
1200 : : field->seqnum);
1201 : :
1202 : 0 : return trace_handle_return(s);
1203 : : }
1204 : :
1205 : : static struct trace_event_functions trace_hwlat_funcs = {
1206 : : .trace = trace_hwlat_print,
1207 : : .raw = trace_hwlat_raw,
1208 : : };
1209 : :
1210 : : static struct trace_event trace_hwlat_event = {
1211 : : .type = TRACE_HWLAT,
1212 : : .funcs = &trace_hwlat_funcs,
1213 : : };
1214 : :
1215 : : /* TRACE_BPUTS */
1216 : : static enum print_line_t
1217 : 0 : trace_bputs_print(struct trace_iterator *iter, int flags,
1218 : : struct trace_event *event)
1219 : : {
1220 : 0 : struct trace_entry *entry = iter->ent;
1221 : 0 : struct trace_seq *s = &iter->seq;
1222 : 0 : struct bputs_entry *field;
1223 : :
1224 [ # # ]: 0 : trace_assign_type(field, entry);
1225 : :
1226 : 0 : seq_print_ip_sym(s, field->ip, flags);
1227 : 0 : trace_seq_puts(s, ": ");
1228 : 0 : trace_seq_puts(s, field->str);
1229 : :
1230 : 0 : return trace_handle_return(s);
1231 : : }
1232 : :
1233 : :
1234 : : static enum print_line_t
1235 : 0 : trace_bputs_raw(struct trace_iterator *iter, int flags,
1236 : : struct trace_event *event)
1237 : : {
1238 : 0 : struct bputs_entry *field;
1239 : 0 : struct trace_seq *s = &iter->seq;
1240 : :
1241 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1242 : :
1243 : 0 : trace_seq_printf(s, ": %lx : ", field->ip);
1244 : 0 : trace_seq_puts(s, field->str);
1245 : :
1246 : 0 : return trace_handle_return(s);
1247 : : }
1248 : :
1249 : : static struct trace_event_functions trace_bputs_funcs = {
1250 : : .trace = trace_bputs_print,
1251 : : .raw = trace_bputs_raw,
1252 : : };
1253 : :
1254 : : static struct trace_event trace_bputs_event = {
1255 : : .type = TRACE_BPUTS,
1256 : : .funcs = &trace_bputs_funcs,
1257 : : };
1258 : :
1259 : : /* TRACE_BPRINT */
1260 : : static enum print_line_t
1261 : 0 : trace_bprint_print(struct trace_iterator *iter, int flags,
1262 : : struct trace_event *event)
1263 : : {
1264 : 0 : struct trace_entry *entry = iter->ent;
1265 : 0 : struct trace_seq *s = &iter->seq;
1266 : 0 : struct bprint_entry *field;
1267 : :
1268 [ # # ]: 0 : trace_assign_type(field, entry);
1269 : :
1270 : 0 : seq_print_ip_sym(s, field->ip, flags);
1271 : 0 : trace_seq_puts(s, ": ");
1272 : 0 : trace_seq_bprintf(s, field->fmt, field->buf);
1273 : :
1274 : 0 : return trace_handle_return(s);
1275 : : }
1276 : :
1277 : :
1278 : : static enum print_line_t
1279 : 0 : trace_bprint_raw(struct trace_iterator *iter, int flags,
1280 : : struct trace_event *event)
1281 : : {
1282 : 0 : struct bprint_entry *field;
1283 : 0 : struct trace_seq *s = &iter->seq;
1284 : :
1285 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1286 : :
1287 : 0 : trace_seq_printf(s, ": %lx : ", field->ip);
1288 : 0 : trace_seq_bprintf(s, field->fmt, field->buf);
1289 : :
1290 : 0 : return trace_handle_return(s);
1291 : : }
1292 : :
1293 : : static struct trace_event_functions trace_bprint_funcs = {
1294 : : .trace = trace_bprint_print,
1295 : : .raw = trace_bprint_raw,
1296 : : };
1297 : :
1298 : : static struct trace_event trace_bprint_event = {
1299 : : .type = TRACE_BPRINT,
1300 : : .funcs = &trace_bprint_funcs,
1301 : : };
1302 : :
1303 : : /* TRACE_PRINT */
1304 : 0 : static enum print_line_t trace_print_print(struct trace_iterator *iter,
1305 : : int flags, struct trace_event *event)
1306 : : {
1307 : 0 : struct print_entry *field;
1308 : 0 : struct trace_seq *s = &iter->seq;
1309 : :
1310 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1311 : :
1312 : 0 : seq_print_ip_sym(s, field->ip, flags);
1313 : 0 : trace_seq_printf(s, ": %s", field->buf);
1314 : :
1315 : 0 : return trace_handle_return(s);
1316 : : }
1317 : :
1318 : 0 : static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags,
1319 : : struct trace_event *event)
1320 : : {
1321 : 0 : struct print_entry *field;
1322 : :
1323 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1324 : :
1325 : 0 : trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf);
1326 : :
1327 : 0 : return trace_handle_return(&iter->seq);
1328 : : }
1329 : :
1330 : : static struct trace_event_functions trace_print_funcs = {
1331 : : .trace = trace_print_print,
1332 : : .raw = trace_print_raw,
1333 : : };
1334 : :
1335 : : static struct trace_event trace_print_event = {
1336 : : .type = TRACE_PRINT,
1337 : : .funcs = &trace_print_funcs,
1338 : : };
1339 : :
1340 : 0 : static enum print_line_t trace_raw_data(struct trace_iterator *iter, int flags,
1341 : : struct trace_event *event)
1342 : : {
1343 : 0 : struct raw_data_entry *field;
1344 : 0 : int i;
1345 : :
1346 [ # # ]: 0 : trace_assign_type(field, iter->ent);
1347 : :
1348 : 0 : trace_seq_printf(&iter->seq, "# %x buf:", field->id);
1349 : :
1350 [ # # ]: 0 : for (i = 0; i < iter->ent_size - offsetof(struct raw_data_entry, buf); i++)
1351 : 0 : trace_seq_printf(&iter->seq, " %02x",
1352 : 0 : (unsigned char)field->buf[i]);
1353 : :
1354 : 0 : trace_seq_putc(&iter->seq, '\n');
1355 : :
1356 : 0 : return trace_handle_return(&iter->seq);
1357 : : }
1358 : :
1359 : : static struct trace_event_functions trace_raw_data_funcs = {
1360 : : .trace = trace_raw_data,
1361 : : .raw = trace_raw_data,
1362 : : };
1363 : :
1364 : : static struct trace_event trace_raw_data_event = {
1365 : : .type = TRACE_RAW_DATA,
1366 : : .funcs = &trace_raw_data_funcs,
1367 : : };
1368 : :
1369 : :
1370 : : static struct trace_event *events[] __initdata = {
1371 : : &trace_fn_event,
1372 : : &trace_ctx_event,
1373 : : &trace_wake_event,
1374 : : &trace_stack_event,
1375 : : &trace_user_stack_event,
1376 : : &trace_bputs_event,
1377 : : &trace_bprint_event,
1378 : : &trace_print_event,
1379 : : &trace_hwlat_event,
1380 : : &trace_raw_data_event,
1381 : : NULL
1382 : : };
1383 : :
1384 : 11 : __init static int init_events(void)
1385 : : {
1386 : 11 : struct trace_event *event;
1387 : 11 : int i, ret;
1388 : :
1389 [ + + ]: 121 : for (i = 0; events[i]; i++) {
1390 : 110 : event = events[i];
1391 : :
1392 : 110 : ret = register_trace_event(event);
1393 [ - + ]: 110 : if (!ret) {
1394 : 0 : printk(KERN_WARNING "event %d failed to register\n",
1395 : : event->type);
1396 : 0 : WARN_ON_ONCE(1);
1397 : : }
1398 : : }
1399 : :
1400 : 11 : return 0;
1401 : : }
1402 : : early_initcall(init_events);
|
