projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
trace: judicious error checking of trace_seq results
[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
ACM		 335 return trace_seq_printf(s, "%16s-%-5d [%03d] %5lu.%06lu: ",
336 comm, entry->pid, entry->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,
359 entry->pid, entry->cpu, entry->flags,
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 {
d9793bd8
ACM		 367 ret = lat_print_generic(s, entry, entry->cpu);
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
438 key = event->type & (EVENT_HASHSIZE - 1);
439
440 hlist_add_head_rcu(&event->node, &event_hash[key]);
441
442 ret = event->type;
443 out:
444 mutex_unlock(&trace_event_mutex);
445
446 return ret;
447}
448
449/**
450 * unregister_ftrace_event - remove a no longer used event
451 * @event: the event to remove
452 */
453int unregister_ftrace_event(struct trace_event *event)
454{
455 mutex_lock(&trace_event_mutex);
456 hlist_del(&event->node);
457 mutex_unlock(&trace_event_mutex);
458
459 return 0;
460}
f633cef0
SR		 461
462/*
463 * Standard events
464 */
465
2c9b238e 466int trace_nop_print(struct trace_iterator *iter, int flags)
f633cef0 467{
d9793bd8 468 return TRACE_TYPE_HANDLED;
f633cef0
SR		 469}
470
471/* TRACE_FN */
2c9b238e 472static int trace_fn_latency(struct trace_iterator *iter, int flags)
f633cef0
SR		 473{
474 struct ftrace_entry *field;
2c9b238e 475 struct trace_seq *s = &iter->seq;
f633cef0 476
2c9b238e 477 trace_assign_type(field, iter->ent);
f633cef0
SR		 478
479 if (!seq_print_ip_sym(s, field->ip, flags))
480 goto partial;
481 if (!trace_seq_puts(s, " ("))
482 goto partial;
483 if (!seq_print_ip_sym(s, field->parent_ip, flags))
484 goto partial;
485 if (!trace_seq_puts(s, ")\n"))
486 goto partial;
487
d9793bd8 488 return TRACE_TYPE_HANDLED;
f633cef0
SR		 489
490 partial:
491 return TRACE_TYPE_PARTIAL_LINE;
492}
493
2c9b238e 494static int trace_fn_trace(struct trace_iterator *iter, int flags)
f633cef0
SR		 495{
496 struct ftrace_entry *field;
2c9b238e 497 struct trace_seq *s = &iter->seq;
f633cef0 498
2c9b238e 499 trace_assign_type(field, iter->ent);
f633cef0
SR		 500
501 if (!seq_print_ip_sym(s, field->ip, flags))
502 goto partial;
503
504 if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
505 if (!trace_seq_printf(s, " <-"))
506 goto partial;
507 if (!seq_print_ip_sym(s,
508 field->parent_ip,
509 flags))
510 goto partial;
511 }
512 if (!trace_seq_printf(s, "\n"))
513 goto partial;
514
d9793bd8 515 return TRACE_TYPE_HANDLED;
f633cef0
SR		 516
517 partial:
518 return TRACE_TYPE_PARTIAL_LINE;
519}
520
2c9b238e 521static int trace_fn_raw(struct trace_iterator *iter, int flags)
f633cef0
SR		 522{
523 struct ftrace_entry *field;
524
2c9b238e 525 trace_assign_type(field, iter->ent);
f633cef0 526
2c9b238e 527 if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
6c1a99af
LJ		 528 field->ip,
529 field->parent_ip))
f633cef0
SR		 530 return TRACE_TYPE_PARTIAL_LINE;
531
d9793bd8 532 return TRACE_TYPE_HANDLED;
f633cef0
SR		 533}
534
2c9b238e 535static int trace_fn_hex(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_HEX_FIELD_RET(s, field->ip);
543 SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);
544
d9793bd8 545 return TRACE_TYPE_HANDLED;
f633cef0
SR		 546}
547
2c9b238e 548static int trace_fn_bin(struct trace_iterator *iter, int flags)
f633cef0
SR		 549{
550 struct ftrace_entry *field;
2c9b238e 551 struct trace_seq *s = &iter->seq;
f633cef0 552
2c9b238e 553 trace_assign_type(field, iter->ent);
f633cef0
SR		 554
555 SEQ_PUT_FIELD_RET(s, field->ip);
556 SEQ_PUT_FIELD_RET(s, field->parent_ip);
557
d9793bd8 558 return TRACE_TYPE_HANDLED;
f633cef0
SR		 559}
560
561static struct trace_event trace_fn_event = {
562 .type = TRACE_FN,
563 .trace = trace_fn_trace,
564 .latency_trace = trace_fn_latency,
565 .raw = trace_fn_raw,
566 .hex = trace_fn_hex,
567 .binary = trace_fn_bin,
568};
569
570/* TRACE_CTX an TRACE_WAKE */
2c9b238e 571static int trace_ctxwake_print(struct trace_iterator *iter, char *delim)
f633cef0
SR		 572{
573 struct ctx_switch_entry *field;
574 char *comm;
575 int S, T;
576
2c9b238e 577 trace_assign_type(field, iter->ent);
f633cef0
SR		 578
579 T = task_state_char(field->next_state);
580 S = task_state_char(field->prev_state);
581 comm = trace_find_cmdline(field->next_pid);
2c9b238e
ACM		 582 if (!trace_seq_printf(&iter->seq,
583 " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
6c1a99af
LJ		 584 field->prev_pid,
585 field->prev_prio,
586 S, delim,
587 field->next_cpu,
588 field->next_pid,
589 field->next_prio,
590 T, comm))
f633cef0
SR		 591 return TRACE_TYPE_PARTIAL_LINE;
592
d9793bd8 593 return TRACE_TYPE_HANDLED;
f633cef0
SR		 594}
595
2c9b238e 596static int trace_ctx_print(struct trace_iterator *iter, int flags)
f633cef0 597{
2c9b238e 598 return trace_ctxwake_print(iter, "==>");
f633cef0
SR		 599}
600
2c9b238e 601static int trace_wake_print(struct trace_iterator *iter, int flags)
f633cef0 602{
2c9b238e 603 return trace_ctxwake_print(iter, " +");
f633cef0
SR		 604}
605
2c9b238e 606static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
f633cef0
SR		 607{
608 struct ctx_switch_entry *field;
609 int T;
610
2c9b238e 611 trace_assign_type(field, iter->ent);
f633cef0
SR		 612
613 if (!S)
614 task_state_char(field->prev_state);
615 T = task_state_char(field->next_state);
2c9b238e 616 if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
6c1a99af
LJ		 617 field->prev_pid,
618 field->prev_prio,
619 S,
620 field->next_cpu,
621 field->next_pid,
622 field->next_prio,
623 T))
f633cef0
SR		 624 return TRACE_TYPE_PARTIAL_LINE;
625
d9793bd8 626 return TRACE_TYPE_HANDLED;
f633cef0
SR		 627}
628
2c9b238e 629static int trace_ctx_raw(struct trace_iterator *iter, int flags)
f633cef0 630{
2c9b238e 631 return trace_ctxwake_raw(iter, 0);
f633cef0
SR		 632}
633
2c9b238e 634static int trace_wake_raw(struct trace_iterator *iter, int flags)
f633cef0 635{
2c9b238e 636 return trace_ctxwake_raw(iter, '+');
f633cef0
SR		 637}
638
639
2c9b238e 640static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
f633cef0
SR		 641{
642 struct ctx_switch_entry *field;
2c9b238e 643 struct trace_seq *s = &iter->seq;
f633cef0
SR		 644 int T;
645
2c9b238e 646 trace_assign_type(field, iter->ent);
f633cef0
SR		 647
648 if (!S)
649 task_state_char(field->prev_state);
650 T = task_state_char(field->next_state);
651
652 SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
653 SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
654 SEQ_PUT_HEX_FIELD_RET(s, S);
655 SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
656 SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
657 SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
658 SEQ_PUT_HEX_FIELD_RET(s, T);
659
d9793bd8 660 return TRACE_TYPE_HANDLED;
f633cef0
SR		 661}
662
2c9b238e 663static int trace_ctx_hex(struct trace_iterator *iter, int flags)
f633cef0 664{
2c9b238e 665 return trace_ctxwake_hex(iter, 0);
f633cef0
SR		 666}
667
2c9b238e 668static int trace_wake_hex(struct trace_iterator *iter, int flags)
f633cef0 669{
2c9b238e 670 return trace_ctxwake_hex(iter, '+');
f633cef0
SR		 671}
672
2c9b238e 673static int trace_ctxwake_bin(struct trace_iterator *iter, int flags)
f633cef0
SR		 674{
675 struct ctx_switch_entry *field;
2c9b238e 676 struct trace_seq *s = &iter->seq;
f633cef0 677
2c9b238e 678 trace_assign_type(field, iter->ent);
f633cef0
SR		 679
680 SEQ_PUT_FIELD_RET(s, field->prev_pid);
681 SEQ_PUT_FIELD_RET(s, field->prev_prio);
682 SEQ_PUT_FIELD_RET(s, field->prev_state);
683 SEQ_PUT_FIELD_RET(s, field->next_pid);
684 SEQ_PUT_FIELD_RET(s, field->next_prio);
685 SEQ_PUT_FIELD_RET(s, field->next_state);
686
d9793bd8 687 return TRACE_TYPE_HANDLED;
f633cef0
SR		 688}
689
690static struct trace_event trace_ctx_event = {
691 .type = TRACE_CTX,
692 .trace = trace_ctx_print,
693 .latency_trace = trace_ctx_print,
694 .raw = trace_ctx_raw,
695 .hex = trace_ctx_hex,
696 .binary = trace_ctxwake_bin,
697};
698
699static struct trace_event trace_wake_event = {
700 .type = TRACE_WAKE,
701 .trace = trace_wake_print,
702 .latency_trace = trace_wake_print,
703 .raw = trace_wake_raw,
704 .hex = trace_wake_hex,
705 .binary = trace_ctxwake_bin,
706};
707
708/* TRACE_SPECIAL */
2c9b238e 709static int trace_special_print(struct trace_iterator *iter, int flags)
f633cef0
SR		 710{
711 struct special_entry *field;
712
2c9b238e 713 trace_assign_type(field, iter->ent);
f633cef0 714
2c9b238e 715 if (!trace_seq_printf(&iter->seq, "# %ld %ld %ld\n",
6c1a99af
LJ		 716 field->arg1,
717 field->arg2,
718 field->arg3))
f633cef0
SR		 719 return TRACE_TYPE_PARTIAL_LINE;
720
d9793bd8 721 return TRACE_TYPE_HANDLED;
f633cef0
SR		 722}
723
2c9b238e 724static int trace_special_hex(struct trace_iterator *iter, int flags)
f633cef0
SR		 725{
726 struct special_entry *field;
2c9b238e 727 struct trace_seq *s = &iter->seq;
f633cef0 728
2c9b238e 729 trace_assign_type(field, iter->ent);
f633cef0
SR		 730
731 SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
732 SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
733 SEQ_PUT_HEX_FIELD_RET(s, field->arg3);
734
d9793bd8 735 return TRACE_TYPE_HANDLED;
f633cef0
SR		 736}
737
2c9b238e 738static int trace_special_bin(struct trace_iterator *iter, int flags)
f633cef0
SR		 739{
740 struct special_entry *field;
2c9b238e 741 struct trace_seq *s = &iter->seq;
f633cef0 742
2c9b238e 743 trace_assign_type(field, iter->ent);
f633cef0
SR		 744
745 SEQ_PUT_FIELD_RET(s, field->arg1);
746 SEQ_PUT_FIELD_RET(s, field->arg2);
747 SEQ_PUT_FIELD_RET(s, field->arg3);
748
d9793bd8 749 return TRACE_TYPE_HANDLED;
f633cef0
SR		 750}
751
752static struct trace_event trace_special_event = {
753 .type = TRACE_SPECIAL,
754 .trace = trace_special_print,
755 .latency_trace = trace_special_print,
756 .raw = trace_special_print,
757 .hex = trace_special_hex,
758 .binary = trace_special_bin,
759};
760
761/* TRACE_STACK */
762
2c9b238e 763static int trace_stack_print(struct trace_iterator *iter, int flags)
f633cef0
SR		 764{
765 struct stack_entry *field;
2c9b238e 766 struct trace_seq *s = &iter->seq;
f633cef0
SR		 767 int i;
768
2c9b238e 769 trace_assign_type(field, iter->ent);
f633cef0
SR		 770
771 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
772 if (i) {
6c1a99af 773 if (!trace_seq_puts(s, " <= "))
f633cef0
SR		 774 goto partial;
775
6c1a99af 776 if (!seq_print_ip_sym(s, field->caller[i], flags))
f633cef0
SR		 777 goto partial;
778 }
6c1a99af 779 if (!trace_seq_puts(s, "\n"))
f633cef0
SR		 780 goto partial;
781 }
782
d9793bd8 783 return TRACE_TYPE_HANDLED;
f633cef0
SR		 784
785 partial:
786 return TRACE_TYPE_PARTIAL_LINE;
787}
788
789static struct trace_event trace_stack_event = {
790 .type = TRACE_STACK,
791 .trace = trace_stack_print,
792 .latency_trace = trace_stack_print,
793 .raw = trace_special_print,
794 .hex = trace_special_hex,
795 .binary = trace_special_bin,
796};
797
798/* TRACE_USER_STACK */
2c9b238e 799static int trace_user_stack_print(struct trace_iterator *iter, int flags)
f633cef0
SR		 800{
801 struct userstack_entry *field;
2c9b238e 802 struct trace_seq *s = &iter->seq;
f633cef0 803
2c9b238e 804 trace_assign_type(field, iter->ent);
f633cef0 805
6c1a99af 806 if (!seq_print_userip_objs(field, s, flags))
f633cef0
SR		 807 goto partial;
808
6c1a99af 809 if (!trace_seq_putc(s, '\n'))
f633cef0
SR		 810 goto partial;
811
d9793bd8 812 return TRACE_TYPE_HANDLED;
f633cef0
SR		 813
814 partial:
815 return TRACE_TYPE_PARTIAL_LINE;
816}
817
818static struct trace_event trace_user_stack_event = {
819 .type = TRACE_USER_STACK,
820 .trace = trace_user_stack_print,
821 .latency_trace = trace_user_stack_print,
822 .raw = trace_special_print,
823 .hex = trace_special_hex,
824 .binary = trace_special_bin,
825};
826
827/* TRACE_PRINT */
2c9b238e 828static int trace_print_print(struct trace_iterator *iter, int flags)
f633cef0
SR		 829{
830 struct print_entry *field;
2c9b238e 831 struct trace_seq *s = &iter->seq;
f633cef0 832
2c9b238e 833 trace_assign_type(field, iter->ent);
f633cef0 834
6c1a99af 835 if (!seq_print_ip_sym(s, field->ip, flags))
f633cef0
SR		 836 goto partial;
837
6c1a99af 838 if (!trace_seq_printf(s, ": %s", field->buf))
f633cef0
SR		 839 goto partial;
840
d9793bd8 841 return TRACE_TYPE_HANDLED;
f633cef0
SR		 842
843 partial:
844 return TRACE_TYPE_PARTIAL_LINE;
845}
846
2c9b238e 847static int trace_print_raw(struct trace_iterator *iter, int flags)
f633cef0
SR		 848{
849 struct print_entry *field;
850
2c9b238e 851 trace_assign_type(field, iter->ent);
f633cef0 852
2c9b238e 853 if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
f633cef0
SR		 854 goto partial;
855
d9793bd8 856 return TRACE_TYPE_HANDLED;
f633cef0
SR		 857
858 partial:
859 return TRACE_TYPE_PARTIAL_LINE;
860}
861
862static struct trace_event trace_print_event = {
863 .type = TRACE_PRINT,
864 .trace = trace_print_print,
865 .latency_trace = trace_print_print,
866 .raw = trace_print_raw,
867 .hex = trace_nop_print,
868 .binary = trace_nop_print,
869};
870
871static struct trace_event *events[] __initdata = {
872 &trace_fn_event,
873 &trace_ctx_event,
874 &trace_wake_event,
875 &trace_special_event,
876 &trace_stack_event,
877 &trace_user_stack_event,
878 &trace_print_event,
879 NULL
880};
881
882__init static int init_events(void)
883{
884 struct trace_event *event;
885 int i, ret;
886
887 for (i = 0; events[i]; i++) {
888 event = events[i];
889
890 ret = register_ftrace_event(event);
891 if (!ret) {
892 printk(KERN_WARNING "event %d failed to register\n",
893 event->type);
894 WARN_ON_ONCE(1);
895 }
896 }
897
898 return 0;
899}
900device_initcall(init_events);
Linux 6.x block layer and io_uring tree(s)