projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'core/printk' into tracing/ftrace
[linux-2.6-block.git] / kernel / trace / trace_output.c
CommitLineData
f0868d1e
SR		 1/*
2 * trace_output.c
3 *
4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
5 *
6 */
7
8#include <linux/module.h>
9#include <linux/mutex.h>
10#include <linux/ftrace.h>
11
12#include "trace_output.h"
13
14/* must be a power of 2 */
15#define EVENT_HASHSIZE 128
16
17static DEFINE_MUTEX(trace_event_mutex);
18static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;
19
20static int next_event_type = __TRACE_LAST_TYPE + 1;
21
22/**
23 * trace_seq_printf - sequence printing of trace information
24 * @s: trace sequence descriptor
25 * @fmt: printf format string
26 *
27 * The tracer may use either sequence operations or its own
28 * copy to user routines. To simplify formating of a trace
29 * trace_seq_printf is used to store strings into a special
30 * buffer (@s). Then the output may be either used by
31 * the sequencer or pulled into another buffer.
32 */
33int
34trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
35{
36 int len = (PAGE_SIZE - 1) - s->len;
37 va_list ap;
38 int ret;
39
40 if (!len)
41 return 0;
42
43 va_start(ap, fmt);
44 ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
45 va_end(ap);
46
47 /* If we can't write it all, don't bother writing anything */
48 if (ret >= len)
49 return 0;
50
51 s->len += ret;
52
53 return len;
54}
55
56/**
57 * trace_seq_puts - trace sequence printing of simple string
58 * @s: trace sequence descriptor
59 * @str: simple string to record
60 *
61 * The tracer may use either the sequence operations or its own
62 * copy to user routines. This function records a simple string
63 * into a special buffer (@s) for later retrieval by a sequencer
64 * or other mechanism.
65 */
66int trace_seq_puts(struct trace_seq *s, const char *str)
67{
68 int len = strlen(str);
69
70 if (len > ((PAGE_SIZE - 1) - s->len))
71 return 0;
72
73 memcpy(s->buffer + s->len, str, len);
74 s->len += len;
75
76 return len;
77}
78
79int trace_seq_putc(struct trace_seq *s, unsigned char c)
80{
81 if (s->len >= (PAGE_SIZE - 1))
82 return 0;
83
84 s->buffer[s->len++] = c;
85
86 return 1;
87}
88
89int trace_seq_putmem(struct trace_seq *s, void *mem, size_t len)
90{
91 if (len > ((PAGE_SIZE - 1) - s->len))
92 return 0;
93
94 memcpy(s->buffer + s->len, mem, len);
95 s->len += len;
96
97 return len;
98}
99
100int trace_seq_putmem_hex(struct trace_seq *s, void *mem, size_t len)
101{
102 unsigned char hex[HEX_CHARS];
103 unsigned char *data = mem;
104 int i, j;
105
106#ifdef __BIG_ENDIAN
107 for (i = 0, j = 0; i < len; i++) {
108#else
109 for (i = len-1, j = 0; i >= 0; i--) {
110#endif
111 hex[j++] = hex_asc_hi(data[i]);
112 hex[j++] = hex_asc_lo(data[i]);
113 }
114 hex[j++] = ' ';
115
116 return trace_seq_putmem(s, hex, j);
117}
118
119int trace_seq_path(struct trace_seq *s, struct path *path)
120{
121 unsigned char *p;
122
123 if (s->len >= (PAGE_SIZE - 1))
124 return 0;
125 p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
126 if (!IS_ERR(p)) {
127 p = mangle_path(s->buffer + s->len, p, "\n");
128 if (p) {
129 s->len = p - s->buffer;
130 return 1;
131 }
132 } else {
133 s->buffer[s->len++] = '?';
134 return 1;
135 }
136
137 return 0;
138}
139
140#ifdef CONFIG_KRETPROBES
141static inline const char *kretprobed(const char *name)
142{
143 static const char tramp_name[] = "kretprobe_trampoline";
144 int size = sizeof(tramp_name);
145
146 if (strncmp(tramp_name, name, size) == 0)
147 return "[unknown/kretprobe'd]";
148 return name;
149}
150#else
151static inline const char *kretprobed(const char *name)
152{
153 return name;
154}
155#endif /* CONFIG_KRETPROBES */
156
157static int
158seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
159{
160#ifdef CONFIG_KALLSYMS
161 char str[KSYM_SYMBOL_LEN];
162 const char *name;
163
164 kallsyms_lookup(address, NULL, NULL, NULL, str);
165
166 name = kretprobed(str);
167
168 return trace_seq_printf(s, fmt, name);
169#endif
170 return 1;
171}
172
173static int
174seq_print_sym_offset(struct trace_seq *s, const char *fmt,
175 unsigned long address)
176{
177#ifdef CONFIG_KALLSYMS
178 char str[KSYM_SYMBOL_LEN];
179 const char *name;
180
181 sprint_symbol(str, address);
182 name = kretprobed(str);
183
184 return trace_seq_printf(s, fmt, name);
185#endif
186 return 1;
187}
188
189#ifndef CONFIG_64BIT
190# define IP_FMT "%08lx"
191#else
192# define IP_FMT "%016lx"
193#endif
194
195int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
196 unsigned long ip, unsigned long sym_flags)
197{
198 struct file *file = NULL;
199 unsigned long vmstart = 0;
200 int ret = 1;
201
202 if (mm) {
203 const struct vm_area_struct *vma;
204
205 down_read(&mm->mmap_sem);
206 vma = find_vma(mm, ip);
207 if (vma) {
208 file = vma->vm_file;
209 vmstart = vma->vm_start;
210 }
211 if (file) {
212 ret = trace_seq_path(s, &file->f_path);
213 if (ret)
214 ret = trace_seq_printf(s, "[+0x%lx]",
215 ip - vmstart);
216 }
217 up_read(&mm->mmap_sem);
218 }
219 if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
220 ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
221 return ret;
222}
223
224int
225seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
226 unsigned long sym_flags)
227{
228 struct mm_struct *mm = NULL;
229 int ret = 1;
230 unsigned int i;
231
232 if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
233 struct task_struct *task;
234 /*
235 * we do the lookup on the thread group leader,
236 * since individual threads might have already quit!
237 */
238 rcu_read_lock();
239 task = find_task_by_vpid(entry->ent.tgid);
240 if (task)
241 mm = get_task_mm(task);
242 rcu_read_unlock();
243 }
244
245 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
246 unsigned long ip = entry->caller[i];
247
248 if (ip == ULONG_MAX || !ret)
249 break;
250 if (i && ret)
251 ret = trace_seq_puts(s, " <- ");
252 if (!ip) {
253 if (ret)
254 ret = trace_seq_puts(s, "??");
255 continue;
256 }
257 if (!ret)
258 break;
259 if (ret)
260 ret = seq_print_user_ip(s, mm, ip, sym_flags);
261 }
262
263 if (mm)
264 mmput(mm);
265 return ret;
266}
267
268int
269seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
270{
271 int ret;
272
273 if (!ip)
274 return trace_seq_printf(s, "0");
275
276 if (sym_flags & TRACE_ITER_SYM_OFFSET)
277 ret = seq_print_sym_offset(s, "%s", ip);
278 else
279 ret = seq_print_sym_short(s, "%s", ip);
280
281 if (!ret)
282 return 0;
283
284 if (sym_flags & TRACE_ITER_SYM_ADDR)
285 ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
286 return ret;
287}
288
d9793bd8 289static int
c4a8e8be
FW		 290lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
291{
292 int hardirq, softirq;
293 char *comm;
294
295 comm = trace_find_cmdline(entry->pid);
c4a8e8be
FW		 296 hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
297 softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
d9793bd8
ACM		 298
299 if (!trace_seq_printf(s, "%8.8s-%-5d %3d%c%c%c",
300 comm, entry->pid, cpu,
301 (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
302 (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
303 'X' : '.',
304 (entry->flags & TRACE_FLAG_NEED_RESCHED) ?
305 'N' : '.',
306 (hardirq && softirq) ? 'H' :
307 hardirq ? 'h' : softirq ? 's' : '.'))
308 return 0;
c4a8e8be
FW		 309
310 if (entry->preempt_count)
d9793bd8
ACM		 311 return trace_seq_printf(s, "%x", entry->preempt_count);
312 return trace_seq_puts(s, ".");
c4a8e8be
FW		 313}
314
315static unsigned long preempt_mark_thresh = 100;
316
d9793bd8 317static int
c4a8e8be
FW		 318lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
319 unsigned long rel_usecs)
320{
d9793bd8
ACM		 321 return trace_seq_printf(s, " %4lldus%c: ", abs_usecs,
322 rel_usecs > preempt_mark_thresh ? '!' :
323 rel_usecs > 1 ? '+' : ' ');
c4a8e8be
FW		 324}
325
326int trace_print_context(struct trace_iterator *iter)
327{
328 struct trace_seq *s = &iter->seq;
329 struct trace_entry *entry = iter->ent;
330 char *comm = trace_find_cmdline(entry->pid);
331 unsigned long long t = ns2usecs(iter->ts);
332 unsigned long usec_rem = do_div(t, USEC_PER_SEC);
333 unsigned long secs = (unsigned long)t;
334
d9793bd8 335 return trace_seq_printf(s, "%16s-%-5d [%03d] %5lu.%06lu: ",
1830b52d 336 comm, entry->pid, iter->cpu, secs, usec_rem);
c4a8e8be
FW		 337}
338
339int trace_print_lat_context(struct trace_iterator *iter)
340{
341 u64 next_ts;
d9793bd8 342 int ret;
c4a8e8be
FW		 343 struct trace_seq *s = &iter->seq;
344 struct trace_entry *entry = iter->ent,
345 *next_entry = trace_find_next_entry(iter, NULL,
346 &next_ts);
347 unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
348 unsigned long abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
349 unsigned long rel_usecs;
350
351 if (!next_entry)
352 next_ts = iter->ts;
353 rel_usecs = ns2usecs(next_ts - iter->ts);
354
355 if (verbose) {
356 char *comm = trace_find_cmdline(entry->pid);
d9793bd8
ACM		 357 ret = trace_seq_printf(s, "%16s %5d %3d %d %08x %08lx [%08lx]"
358 " %ld.%03ldms (+%ld.%03ldms): ", comm,
1830b52d 359 entry->pid, iter->cpu, entry->flags,
d9793bd8
ACM		 360 entry->preempt_count, iter->idx,
361 ns2usecs(iter->ts),
362 abs_usecs / USEC_PER_MSEC,
363 abs_usecs % USEC_PER_MSEC,
364 rel_usecs / USEC_PER_MSEC,
365 rel_usecs % USEC_PER_MSEC);
c4a8e8be 366 } else {
1830b52d 367 ret = lat_print_generic(s, entry, iter->cpu);
d9793bd8
ACM		 368 if (ret)
369 ret = lat_print_timestamp(s, abs_usecs, rel_usecs);
c4a8e8be
FW		 370 }
371
d9793bd8 372 return ret;
c4a8e8be
FW		 373}
374
f633cef0
SR		 375static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;
376
377static int task_state_char(unsigned long state)
378{
379 int bit = state ? __ffs(state) + 1 : 0;
380
381 return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
382}
383
f0868d1e
SR		 384/**
385 * ftrace_find_event - find a registered event
386 * @type: the type of event to look for
387 *
388 * Returns an event of type @type otherwise NULL
389 */
390struct trace_event *ftrace_find_event(int type)
391{
392 struct trace_event *event;
393 struct hlist_node *n;
394 unsigned key;
395
396 key = type & (EVENT_HASHSIZE - 1);
397
398 hlist_for_each_entry_rcu(event, n, &event_hash[key], node) {
399 if (event->type == type)
400 return event;
401 }
402
403 return NULL;
404}
405
406/**
407 * register_ftrace_event - register output for an event type
408 * @event: the event type to register
409 *
410 * Event types are stored in a hash and this hash is used to
411 * find a way to print an event. If the @event->type is set
412 * then it will use that type, otherwise it will assign a
413 * type to use.
414 *
415 * If you assign your own type, please make sure it is added
416 * to the trace_type enum in trace.h, to avoid collisions
417 * with the dynamic types.
418 *
419 * Returns the event type number or zero on error.
420 */
421int register_ftrace_event(struct trace_event *event)
422{
423 unsigned key;
424 int ret = 0;
425
426 mutex_lock(&trace_event_mutex);
427
428 if (!event->type)
429 event->type = next_event_type++;
430 else if (event->type > __TRACE_LAST_TYPE) {
431 printk(KERN_WARNING "Need to add type to trace.h\n");
432 WARN_ON(1);
433 }
434
435 if (ftrace_find_event(event->type))
436 goto out;
437
268ccda0
ACM		 438 if (event->trace == NULL)
439 event->trace = trace_nop_print;
268ccda0
ACM		 440 if (event->raw == NULL)
441 event->raw = trace_nop_print;
442 if (event->hex == NULL)
443 event->hex = trace_nop_print;
444 if (event->binary == NULL)
445 event->binary = trace_nop_print;
446
f0868d1e
SR		 447 key = event->type & (EVENT_HASHSIZE - 1);
448
449 hlist_add_head_rcu(&event->node, &event_hash[key]);
450
451 ret = event->type;
452 out:
453 mutex_unlock(&trace_event_mutex);
454
455 return ret;
456}
457
458/**
459 * unregister_ftrace_event - remove a no longer used event
460 * @event: the event to remove
461 */
462int unregister_ftrace_event(struct trace_event *event)
463{
464 mutex_lock(&trace_event_mutex);
465 hlist_del(&event->node);
466 mutex_unlock(&trace_event_mutex);
467
468 return 0;
469}
f633cef0
SR		 470
471/*
472 * Standard events
473 */
474
ae7462b4 475enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags)
f633cef0 476{
d9793bd8 477 return TRACE_TYPE_HANDLED;
f633cef0
SR		 478}
479
480/* TRACE_FN */
ae7462b4 481static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags)
f633cef0
SR		 482{
483 struct ftrace_entry *field;
2c9b238e 484 struct trace_seq *s = &iter->seq;
f633cef0 485
2c9b238e 486 trace_assign_type(field, iter->ent);
f633cef0
SR		 487
488 if (!seq_print_ip_sym(s, field->ip, flags))
489 goto partial;
490
491 if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
492 if (!trace_seq_printf(s, " <-"))
493 goto partial;
494 if (!seq_print_ip_sym(s,
495 field->parent_ip,
496 flags))
497 goto partial;
498 }
499 if (!trace_seq_printf(s, "\n"))
500 goto partial;
501
d9793bd8 502 return TRACE_TYPE_HANDLED;
f633cef0
SR		 503
504 partial:
505 return TRACE_TYPE_PARTIAL_LINE;
506}
507
ae7462b4 508static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags)
f633cef0
SR		 509{
510 struct ftrace_entry *field;
511
2c9b238e 512 trace_assign_type(field, iter->ent);
f633cef0 513
2c9b238e 514 if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
6c1a99af
LJ		 515 field->ip,
516 field->parent_ip))
f633cef0
SR		 517 return TRACE_TYPE_PARTIAL_LINE;
518
d9793bd8 519 return TRACE_TYPE_HANDLED;
f633cef0
SR		 520}
521
ae7462b4 522static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags)
f633cef0
SR		 523{
524 struct ftrace_entry *field;
2c9b238e 525 struct trace_seq *s = &iter->seq;
f633cef0 526
2c9b238e 527 trace_assign_type(field, iter->ent);
f633cef0
SR		 528
529 SEQ_PUT_HEX_FIELD_RET(s, field->ip);
530 SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
531
d9793bd8 532 return TRACE_TYPE_HANDLED;
f633cef0
SR		 533}
534
ae7462b4 535static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags)
f633cef0
SR		 536{
537 struct ftrace_entry *field;
2c9b238e 538 struct trace_seq *s = &iter->seq;
f633cef0 539
2c9b238e 540 trace_assign_type(field, iter->ent);
f633cef0
SR		 541
542 SEQ_PUT_FIELD_RET(s, field->ip);
543 SEQ_PUT_FIELD_RET(s, field->parent_ip);
544
d9793bd8 545 return TRACE_TYPE_HANDLED;
f633cef0
SR		 546}
547
548static struct trace_event trace_fn_event = {
549 .type = TRACE_FN,
550 .trace = trace_fn_trace,
f633cef0
SR		 551 .raw = trace_fn_raw,
552 .hex = trace_fn_hex,
553 .binary = trace_fn_bin,
554};
555
556/* TRACE_CTX an TRACE_WAKE */
ae7462b4
ACM		 557static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
558 char *delim)
f633cef0
SR		 559{
560 struct ctx_switch_entry *field;
561 char *comm;
562 int S, T;
563
2c9b238e 564 trace_assign_type(field, iter->ent);
f633cef0
SR		 565
566 T = task_state_char(field->next_state);
567 S = task_state_char(field->prev_state);
568 comm = trace_find_cmdline(field->next_pid);
2c9b238e
ACM		 569 if (!trace_seq_printf(&iter->seq,
570 " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
6c1a99af
LJ		 571 field->prev_pid,
572 field->prev_prio,
573 S, delim,
574 field->next_cpu,
575 field->next_pid,
576 field->next_prio,
577 T, comm))
f633cef0
SR		 578 return TRACE_TYPE_PARTIAL_LINE;
579
d9793bd8 580 return TRACE_TYPE_HANDLED;
f633cef0
SR		 581}
582
ae7462b4 583static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags)
f633cef0 584{
2c9b238e 585 return trace_ctxwake_print(iter, "==>");
f633cef0
SR		 586}
587
ae7462b4
ACM		 588static enum print_line_t trace_wake_print(struct trace_iterator *iter,
589 int flags)
f633cef0 590{
2c9b238e 591 return trace_ctxwake_print(iter, " +");
f633cef0
SR		 592}
593
2c9b238e 594static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
f633cef0
SR		 595{
596 struct ctx_switch_entry *field;
597 int T;
598
2c9b238e 599 trace_assign_type(field, iter->ent);
f633cef0
SR		 600
601 if (!S)
602 task_state_char(field->prev_state);
603 T = task_state_char(field->next_state);
2c9b238e 604 if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
6c1a99af
LJ		 605 field->prev_pid,
606 field->prev_prio,
607 S,
608 field->next_cpu,
609 field->next_pid,
610 field->next_prio,
611 T))
f633cef0
SR		 612 return TRACE_TYPE_PARTIAL_LINE;
613
d9793bd8 614 return TRACE_TYPE_HANDLED;
f633cef0
SR		 615}
616
ae7462b4 617static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags)
f633cef0 618{
2c9b238e 619 return trace_ctxwake_raw(iter, 0);
f633cef0
SR		 620}
621
ae7462b4 622static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags)
f633cef0 623{
2c9b238e 624 return trace_ctxwake_raw(iter, '+');
f633cef0
SR		 625}
626
627
2c9b238e 628static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
f633cef0
SR		 629{
630 struct ctx_switch_entry *field;
2c9b238e 631 struct trace_seq *s = &iter->seq;
f633cef0
SR		 632 int T;
633
2c9b238e 634 trace_assign_type(field, iter->ent);
f633cef0
SR		 635
636 if (!S)
637 task_state_char(field->prev_state);
638 T = task_state_char(field->next_state);
639
640 SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
641 SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
642 SEQ_PUT_HEX_FIELD_RET(s, S);
643 SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
644 SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
645 SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
646 SEQ_PUT_HEX_FIELD_RET(s, T);
647
d9793bd8 648 return TRACE_TYPE_HANDLED;
f633cef0
SR		 649}
650
ae7462b4 651static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags)
f633cef0 652{
2c9b238e 653 return trace_ctxwake_hex(iter, 0);
f633cef0
SR		 654}
655
ae7462b4 656static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags)
f633cef0 657{
2c9b238e 658 return trace_ctxwake_hex(iter, '+');
f633cef0
SR		 659}
660
ae7462b4
ACM		 661static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
662 int flags)
f633cef0
SR		 663{
664 struct ctx_switch_entry *field;
2c9b238e 665 struct trace_seq *s = &iter->seq;
f633cef0 666
2c9b238e 667 trace_assign_type(field, iter->ent);
f633cef0
SR		 668
669 SEQ_PUT_FIELD_RET(s, field->prev_pid);
670 SEQ_PUT_FIELD_RET(s, field->prev_prio);
671 SEQ_PUT_FIELD_RET(s, field->prev_state);
672 SEQ_PUT_FIELD_RET(s, field->next_pid);
673 SEQ_PUT_FIELD_RET(s, field->next_prio);
674 SEQ_PUT_FIELD_RET(s, field->next_state);
675
d9793bd8 676 return TRACE_TYPE_HANDLED;
f633cef0
SR		 677}
678
679static struct trace_event trace_ctx_event = {
680 .type = TRACE_CTX,
681 .trace = trace_ctx_print,
f633cef0
SR		 682 .raw = trace_ctx_raw,
683 .hex = trace_ctx_hex,
684 .binary = trace_ctxwake_bin,
685};
686
687static struct trace_event trace_wake_event = {
688 .type = TRACE_WAKE,
689 .trace = trace_wake_print,
f633cef0
SR		 690 .raw = trace_wake_raw,
691 .hex = trace_wake_hex,
692 .binary = trace_ctxwake_bin,
693};
694
695/* TRACE_SPECIAL */
ae7462b4
ACM		 696static enum print_line_t trace_special_print(struct trace_iterator *iter,
697 int flags)
f633cef0
SR		 698{
699 struct special_entry *field;
700
2c9b238e 701 trace_assign_type(field, iter->ent);
f633cef0 702
2c9b238e 703 if (!trace_seq_printf(&iter->seq, "# %ld %ld %ld\n",
6c1a99af
LJ		 704 field->arg1,
705 field->arg2,
706 field->arg3))
f633cef0
SR		 707 return TRACE_TYPE_PARTIAL_LINE;
708
d9793bd8 709 return TRACE_TYPE_HANDLED;
f633cef0
SR		 710}
711
ae7462b4
ACM		 712static enum print_line_t trace_special_hex(struct trace_iterator *iter,
713 int flags)
f633cef0
SR		 714{
715 struct special_entry *field;
2c9b238e 716 struct trace_seq *s = &iter->seq;
f633cef0 717
2c9b238e 718 trace_assign_type(field, iter->ent);
f633cef0
SR		 719
720 SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
721 SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
722 SEQ_PUT_HEX_FIELD_RET(s, field->arg3);
723
d9793bd8 724 return TRACE_TYPE_HANDLED;
f633cef0
SR		 725}
726
ae7462b4
ACM		 727static enum print_line_t trace_special_bin(struct trace_iterator *iter,
728 int flags)
f633cef0
SR		 729{
730 struct special_entry *field;
2c9b238e 731 struct trace_seq *s = &iter->seq;
f633cef0 732
2c9b238e 733 trace_assign_type(field, iter->ent);
f633cef0
SR		 734
735 SEQ_PUT_FIELD_RET(s, field->arg1);
736 SEQ_PUT_FIELD_RET(s, field->arg2);
737 SEQ_PUT_FIELD_RET(s, field->arg3);
738
d9793bd8 739 return TRACE_TYPE_HANDLED;
f633cef0
SR		 740}
741
742static struct trace_event trace_special_event = {
743 .type = TRACE_SPECIAL,
744 .trace = trace_special_print,
f633cef0
SR		 745 .raw = trace_special_print,
746 .hex = trace_special_hex,
747 .binary = trace_special_bin,
748};
749
750/* TRACE_STACK */
751
ae7462b4
ACM		 752static enum print_line_t trace_stack_print(struct trace_iterator *iter,
753 int flags)
f633cef0
SR		 754{
755 struct stack_entry *field;
2c9b238e 756 struct trace_seq *s = &iter->seq;
f633cef0
SR		 757 int i;
758
2c9b238e 759 trace_assign_type(field, iter->ent);
f633cef0
SR		 760
761 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
762 if (i) {
6c1a99af 763 if (!trace_seq_puts(s, " <= "))
f633cef0
SR		 764 goto partial;
765
6c1a99af 766 if (!seq_print_ip_sym(s, field->caller[i], flags))
f633cef0
SR		 767 goto partial;
768 }
6c1a99af 769 if (!trace_seq_puts(s, "\n"))
f633cef0
SR		 770 goto partial;
771 }
772
d9793bd8 773 return TRACE_TYPE_HANDLED;
f633cef0
SR		 774
775 partial:
776 return TRACE_TYPE_PARTIAL_LINE;
777}
778
779static struct trace_event trace_stack_event = {
780 .type = TRACE_STACK,
781 .trace = trace_stack_print,
f633cef0
SR		 782 .raw = trace_special_print,
783 .hex = trace_special_hex,
784 .binary = trace_special_bin,
785};
786
787/* TRACE_USER_STACK */
ae7462b4
ACM		 788static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
789 int flags)
f633cef0
SR		 790{
791 struct userstack_entry *field;
2c9b238e 792 struct trace_seq *s = &iter->seq;
f633cef0 793
2c9b238e 794 trace_assign_type(field, iter->ent);
f633cef0 795
6c1a99af 796 if (!seq_print_userip_objs(field, s, flags))
f633cef0
SR		 797 goto partial;
798
6c1a99af 799 if (!trace_seq_putc(s, '\n'))
f633cef0
SR		 800 goto partial;
801
d9793bd8 802 return TRACE_TYPE_HANDLED;
f633cef0
SR		 803
804 partial:
805 return TRACE_TYPE_PARTIAL_LINE;
806}
807
808static struct trace_event trace_user_stack_event = {
809 .type = TRACE_USER_STACK,
810 .trace = trace_user_stack_print,
f633cef0
SR		 811 .raw = trace_special_print,
812 .hex = trace_special_hex,
813 .binary = trace_special_bin,
814};
815
816/* TRACE_PRINT */
ae7462b4
ACM		 817static enum print_line_t trace_print_print(struct trace_iterator *iter,
818 int flags)
f633cef0
SR		 819{
820 struct print_entry *field;
2c9b238e 821 struct trace_seq *s = &iter->seq;
f633cef0 822
2c9b238e 823 trace_assign_type(field, iter->ent);
f633cef0 824
6c1a99af 825 if (!seq_print_ip_sym(s, field->ip, flags))
f633cef0
SR		 826 goto partial;
827
6c1a99af 828 if (!trace_seq_printf(s, ": %s", field->buf))
f633cef0
SR		 829 goto partial;
830
d9793bd8 831 return TRACE_TYPE_HANDLED;
f633cef0
SR		 832
833 partial:
834 return TRACE_TYPE_PARTIAL_LINE;
835}
836
ae7462b4 837static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags)
f633cef0
SR		 838{
839 struct print_entry *field;
840
2c9b238e 841 trace_assign_type(field, iter->ent);
f633cef0 842
2c9b238e 843 if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
f633cef0
SR		 844 goto partial;
845
d9793bd8 846 return TRACE_TYPE_HANDLED;
f633cef0
SR		 847
848 partial:
849 return TRACE_TYPE_PARTIAL_LINE;
850}
851
852static struct trace_event trace_print_event = {
853 .type = TRACE_PRINT,
854 .trace = trace_print_print,
f633cef0 855 .raw = trace_print_raw,
f633cef0
SR		 856};
857
858static struct trace_event *events[] __initdata = {
859 &trace_fn_event,
860 &trace_ctx_event,
861 &trace_wake_event,
862 &trace_special_event,
863 &trace_stack_event,
864 &trace_user_stack_event,
865 &trace_print_event,
866 NULL
867};
868
869__init static int init_events(void)
870{
871 struct trace_event *event;
872 int i, ret;
873
874 for (i = 0; events[i]; i++) {
875 event = events[i];
876
877 ret = register_ftrace_event(event);
878 if (!ret) {
879 printk(KERN_WARNING "event %d failed to register\n",
880 event->type);
881 WARN_ON_ONCE(1);
882 }
883 }
884
885 return 0;
886}
887device_initcall(init_events);
Linux 6.x block layer and io_uring tree(s)