trace_output.c 25.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
 * trace_output.c
 *
 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
 *
 */

#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/ftrace.h>

#include "trace_output.h"

/* must be a power of 2 */
#define EVENT_HASHSIZE	128

17
DECLARE_RWSEM(trace_event_mutex);
18
19

DEFINE_PER_CPU(struct trace_seq, ftrace_event_seq);
20
EXPORT_PER_CPU_SYMBOL(ftrace_event_seq);
21

22
23
24
25
static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly;

static int next_event_type = __TRACE_LAST_TYPE + 1;

26
27
28
29
void trace_print_seq(struct seq_file *m, struct trace_seq *s)
{
	int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;

30
	seq_write(m, s->buffer, len);
31
32
33
34

	trace_seq_init(s);
}

35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *entry = iter->ent;
	struct bprint_entry *field;
	int ret;

	trace_assign_type(field, entry);

	ret = trace_seq_bprintf(s, field->fmt, field->buf);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *entry = iter->ent;
	struct print_entry *field;
	int ret;

	trace_assign_type(field, entry);

	ret = trace_seq_printf(s, "%s", field->buf);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/**
 * trace_seq_printf - sequence printing of trace information
 * @s: trace sequence descriptor
 * @fmt: printf format string
 *
 * The tracer may use either sequence operations or its own
 * copy to user routines. To simplify formating of a trace
 * trace_seq_printf is used to store strings into a special
 * buffer (@s). Then the output may be either used by
 * the sequencer or pulled into another buffer.
 */
int
trace_seq_printf(struct trace_seq *s, const char *fmt, ...)
{
	int len = (PAGE_SIZE - 1) - s->len;
	va_list ap;
	int ret;

	if (!len)
		return 0;

	va_start(ap, fmt);
	ret = vsnprintf(s->buffer + s->len, len, fmt, ap);
	va_end(ap);

	/* If we can't write it all, don't bother writing anything */
	if (ret >= len)
		return 0;

	s->len += ret;

	return len;
}
100
EXPORT_SYMBOL_GPL(trace_seq_printf);
101

102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/**
 * trace_seq_vprintf - sequence printing of trace information
 * @s: trace sequence descriptor
 * @fmt: printf format string
 *
 * The tracer may use either sequence operations or its own
 * copy to user routines. To simplify formating of a trace
 * trace_seq_printf is used to store strings into a special
 * buffer (@s). Then the output may be either used by
 * the sequencer or pulled into another buffer.
 */
int
trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args)
{
	int len = (PAGE_SIZE - 1) - s->len;
	int ret;

	if (!len)
		return 0;

	ret = vsnprintf(s->buffer + s->len, len, fmt, args);

	/* If we can't write it all, don't bother writing anything */
	if (ret >= len)
		return 0;

	s->len += ret;

	return len;
}
EXPORT_SYMBOL_GPL(trace_seq_vprintf);

134
int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
{
	int len = (PAGE_SIZE - 1) - s->len;
	int ret;

	if (!len)
		return 0;

	ret = bstr_printf(s->buffer + s->len, len, fmt, binary);

	/* If we can't write it all, don't bother writing anything */
	if (ret >= len)
		return 0;

	s->len += ret;

	return len;
}

153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
/**
 * trace_seq_puts - trace sequence printing of simple string
 * @s: trace sequence descriptor
 * @str: simple string to record
 *
 * The tracer may use either the sequence operations or its own
 * copy to user routines. This function records a simple string
 * into a special buffer (@s) for later retrieval by a sequencer
 * or other mechanism.
 */
int trace_seq_puts(struct trace_seq *s, const char *str)
{
	int len = strlen(str);

	if (len > ((PAGE_SIZE - 1) - s->len))
		return 0;

	memcpy(s->buffer + s->len, str, len);
	s->len += len;

	return len;
}

int trace_seq_putc(struct trace_seq *s, unsigned char c)
{
	if (s->len >= (PAGE_SIZE - 1))
		return 0;

	s->buffer[s->len++] = c;

	return 1;
}

186
int trace_seq_putmem(struct trace_seq *s, const void *mem, size_t len)
187
188
189
190
191
192
193
194
195
196
{
	if (len > ((PAGE_SIZE - 1) - s->len))
		return 0;

	memcpy(s->buffer + s->len, mem, len);
	s->len += len;

	return len;
}

197
int trace_seq_putmem_hex(struct trace_seq *s, const void *mem, size_t len)
198
199
{
	unsigned char hex[HEX_CHARS];
200
	const unsigned char *data = mem;
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
	int i, j;

#ifdef __BIG_ENDIAN
	for (i = 0, j = 0; i < len; i++) {
#else
	for (i = len-1, j = 0; i >= 0; i--) {
#endif
		hex[j++] = hex_asc_hi(data[i]);
		hex[j++] = hex_asc_lo(data[i]);
	}
	hex[j++] = ' ';

	return trace_seq_putmem(s, hex, j);
}

216
217
218
219
220
221
222
223
224
225
226
227
228
void *trace_seq_reserve(struct trace_seq *s, size_t len)
{
	void *ret;

	if (len > ((PAGE_SIZE - 1) - s->len))
		return NULL;

	ret = s->buffer + s->len;
	s->len += len;

	return ret;
}

229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
int trace_seq_path(struct trace_seq *s, struct path *path)
{
	unsigned char *p;

	if (s->len >= (PAGE_SIZE - 1))
		return 0;
	p = d_path(path, s->buffer + s->len, PAGE_SIZE - s->len);
	if (!IS_ERR(p)) {
		p = mangle_path(s->buffer + s->len, p, "\n");
		if (p) {
			s->len = p - s->buffer;
			return 1;
		}
	} else {
		s->buffer[s->len++] = '?';
		return 1;
	}

	return 0;
}

250
251
252
253
254
255
256
const char *
ftrace_print_flags_seq(struct trace_seq *p, const char *delim,
		       unsigned long flags,
		       const struct trace_print_flags *flag_array)
{
	unsigned long mask;
	const char *str;
257
	const char *ret = p->buffer + p->len;
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
	int i;

	for (i = 0;  flag_array[i].name && flags; i++) {

		mask = flag_array[i].mask;
		if ((flags & mask) != mask)
			continue;

		str = flag_array[i].name;
		flags &= ~mask;
		if (p->len && delim)
			trace_seq_puts(p, delim);
		trace_seq_puts(p, str);
	}

	/* check for left over flags */
	if (flags) {
		if (p->len && delim)
			trace_seq_puts(p, delim);
		trace_seq_printf(p, "0x%lx", flags);
	}

	trace_seq_putc(p, 0);

282
	return ret;
283
}
284
EXPORT_SYMBOL(ftrace_print_flags_seq);
285

286
287
288
289
290
const char *
ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val,
			 const struct trace_print_flags *symbol_array)
{
	int i;
291
	const char *ret = p->buffer + p->len;
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306

	for (i = 0;  symbol_array[i].name; i++) {

		if (val != symbol_array[i].mask)
			continue;

		trace_seq_puts(p, symbol_array[i].name);
		break;
	}

	if (!p->len)
		trace_seq_printf(p, "0x%lx", val);
		
	trace_seq_putc(p, 0);

307
	return ret;
308
}
309
EXPORT_SYMBOL(ftrace_print_symbols_seq);
310

311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
#ifdef CONFIG_KRETPROBES
static inline const char *kretprobed(const char *name)
{
	static const char tramp_name[] = "kretprobe_trampoline";
	int size = sizeof(tramp_name);

	if (strncmp(tramp_name, name, size) == 0)
		return "[unknown/kretprobe'd]";
	return name;
}
#else
static inline const char *kretprobed(const char *name)
{
	return name;
}
#endif /* CONFIG_KRETPROBES */

static int
seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address)
{
#ifdef CONFIG_KALLSYMS
	char str[KSYM_SYMBOL_LEN];
	const char *name;

	kallsyms_lookup(address, NULL, NULL, NULL, str);

	name = kretprobed(str);

	return trace_seq_printf(s, fmt, name);
#endif
	return 1;
}

static int
seq_print_sym_offset(struct trace_seq *s, const char *fmt,
		     unsigned long address)
{
#ifdef CONFIG_KALLSYMS
	char str[KSYM_SYMBOL_LEN];
	const char *name;

	sprint_symbol(str, address);
	name = kretprobed(str);

	return trace_seq_printf(s, fmt, name);
#endif
	return 1;
}

#ifndef CONFIG_64BIT
# define IP_FMT "%08lx"
#else
# define IP_FMT "%016lx"
#endif

int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm,
		      unsigned long ip, unsigned long sym_flags)
{
	struct file *file = NULL;
	unsigned long vmstart = 0;
	int ret = 1;

	if (mm) {
		const struct vm_area_struct *vma;

		down_read(&mm->mmap_sem);
		vma = find_vma(mm, ip);
		if (vma) {
			file = vma->vm_file;
			vmstart = vma->vm_start;
		}
		if (file) {
			ret = trace_seq_path(s, &file->f_path);
			if (ret)
				ret = trace_seq_printf(s, "[+0x%lx]",
						       ip - vmstart);
		}
		up_read(&mm->mmap_sem);
	}
	if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file))
		ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
	return ret;
}

int
seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s,
		      unsigned long sym_flags)
{
	struct mm_struct *mm = NULL;
	int ret = 1;
	unsigned int i;

	if (trace_flags & TRACE_ITER_SYM_USEROBJ) {
		struct task_struct *task;
		/*
		 * we do the lookup on the thread group leader,
		 * since individual threads might have already quit!
		 */
		rcu_read_lock();
410
		task = find_task_by_vpid(entry->tgid);
411
412
413
414
415
416
417
418
419
420
		if (task)
			mm = get_task_mm(task);
		rcu_read_unlock();
	}

	for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
		unsigned long ip = entry->caller[i];

		if (ip == ULONG_MAX || !ret)
			break;
421
422
		if (ret)
			ret = trace_seq_puts(s, " => ");
423
424
425
		if (!ip) {
			if (ret)
				ret = trace_seq_puts(s, "??");
426
427
			if (ret)
				ret = trace_seq_puts(s, "\n");
428
429
430
431
432
433
			continue;
		}
		if (!ret)
			break;
		if (ret)
			ret = seq_print_user_ip(s, mm, ip, sym_flags);
434
		ret = trace_seq_puts(s, "\n");
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
	}

	if (mm)
		mmput(mm);
	return ret;
}

int
seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags)
{
	int ret;

	if (!ip)
		return trace_seq_printf(s, "0");

	if (sym_flags & TRACE_ITER_SYM_OFFSET)
		ret = seq_print_sym_offset(s, "%s", ip);
	else
		ret = seq_print_sym_short(s, "%s", ip);

	if (!ret)
		return 0;

	if (sym_flags & TRACE_ITER_SYM_ADDR)
		ret = trace_seq_printf(s, " <" IP_FMT ">", ip);
	return ret;
}

463
static int
464
465
466
lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
{
	int hardirq, softirq;
467
	char comm[TASK_COMM_LEN];
468

469
	trace_find_cmdline(entry->pid, comm);
470
471
	hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
	softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
472
473
474
475
476
477
478
479
480
481
482

	if (!trace_seq_printf(s, "%8.8s-%-5d %3d%c%c%c",
			      comm, entry->pid, cpu,
			      (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
				(entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
				  'X' : '.',
			      (entry->flags & TRACE_FLAG_NEED_RESCHED) ?
				'N' : '.',
			      (hardirq && softirq) ? 'H' :
				hardirq ? 'h' : softirq ? 's' : '.'))
		return 0;
483
484

	if (entry->preempt_count)
485
486
		return trace_seq_printf(s, "%x", entry->preempt_count);
	return trace_seq_puts(s, ".");
487
488
489
490
}

static unsigned long preempt_mark_thresh = 100;

491
static int
492
493
494
lat_print_timestamp(struct trace_seq *s, u64 abs_usecs,
		    unsigned long rel_usecs)
{
495
496
497
	return trace_seq_printf(s, " %4lldus%c: ", abs_usecs,
				rel_usecs > preempt_mark_thresh ? '!' :
				  rel_usecs > 1 ? '+' : ' ');
498
499
500
501
502
503
504
505
506
}

int trace_print_context(struct trace_iterator *iter)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *entry = iter->ent;
	unsigned long long t = ns2usecs(iter->ts);
	unsigned long usec_rem = do_div(t, USEC_PER_SEC);
	unsigned long secs = (unsigned long)t;
507
508
509
	char comm[TASK_COMM_LEN];

	trace_find_cmdline(entry->pid, comm);
510

511
	return trace_seq_printf(s, "%16s-%-5d [%03d] %5lu.%06lu: ",
512
				comm, entry->pid, iter->cpu, secs, usec_rem);
513
514
515
516
517
}

int trace_print_lat_context(struct trace_iterator *iter)
{
	u64 next_ts;
518
	int ret;
519
520
521
522
523
524
525
526
527
528
529
530
531
	struct trace_seq *s = &iter->seq;
	struct trace_entry *entry = iter->ent,
			   *next_entry = trace_find_next_entry(iter, NULL,
							       &next_ts);
	unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE);
	unsigned long abs_usecs = ns2usecs(iter->ts - iter->tr->time_start);
	unsigned long rel_usecs;

	if (!next_entry)
		next_ts = iter->ts;
	rel_usecs = ns2usecs(next_ts - iter->ts);

	if (verbose) {
532
533
534
535
		char comm[TASK_COMM_LEN];

		trace_find_cmdline(entry->pid, comm);

536
		ret = trace_seq_printf(s, "%16s %5d %3d %d %08x %08lx [%08llx]"
537
				       " %ld.%03ldms (+%ld.%03ldms): ", comm,
538
				       entry->pid, iter->cpu, entry->flags,
539
540
541
542
543
544
				       entry->preempt_count, iter->idx,
				       ns2usecs(iter->ts),
				       abs_usecs / USEC_PER_MSEC,
				       abs_usecs % USEC_PER_MSEC,
				       rel_usecs / USEC_PER_MSEC,
				       rel_usecs % USEC_PER_MSEC);
545
	} else {
546
		ret = lat_print_generic(s, entry, iter->cpu);
547
548
		if (ret)
			ret = lat_print_timestamp(s, abs_usecs, rel_usecs);
549
550
	}

551
	return ret;
552
553
}

554
555
556
557
558
559
560
561
562
static const char state_to_char[] = TASK_STATE_TO_CHAR_STR;

static int task_state_char(unsigned long state)
{
	int bit = state ? __ffs(state) + 1 : 0;

	return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?';
}

563
564
565
566
567
/**
 * ftrace_find_event - find a registered event
 * @type: the type of event to look for
 *
 * Returns an event of type @type otherwise NULL
568
 * Called with trace_event_read_lock() held.
569
570
571
572
573
574
575
576
577
 */
struct trace_event *ftrace_find_event(int type)
{
	struct trace_event *event;
	struct hlist_node *n;
	unsigned key;

	key = type & (EVENT_HASHSIZE - 1);

578
	hlist_for_each_entry(event, n, &event_hash[key], node) {
579
580
581
582
583
584
585
		if (event->type == type)
			return event;
	}

	return NULL;
}

586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
static LIST_HEAD(ftrace_event_list);

static int trace_search_list(struct list_head **list)
{
	struct trace_event *e;
	int last = __TRACE_LAST_TYPE;

	if (list_empty(&ftrace_event_list)) {
		*list = &ftrace_event_list;
		return last + 1;
	}

	/*
	 * We used up all possible max events,
	 * lets see if somebody freed one.
	 */
	list_for_each_entry(e, &ftrace_event_list, list) {
		if (e->type != last + 1)
			break;
		last++;
	}

	/* Did we used up all 65 thousand events??? */
	if ((last + 1) > FTRACE_MAX_EVENT)
		return 0;

	*list = &e->list;
	return last + 1;
}

616
617
618
619
620
621
622
623
624
625
void trace_event_read_lock(void)
{
	down_read(&trace_event_mutex);
}

void trace_event_read_unlock(void)
{
	up_read(&trace_event_mutex);
}

626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
/**
 * register_ftrace_event - register output for an event type
 * @event: the event type to register
 *
 * Event types are stored in a hash and this hash is used to
 * find a way to print an event. If the @event->type is set
 * then it will use that type, otherwise it will assign a
 * type to use.
 *
 * If you assign your own type, please make sure it is added
 * to the trace_type enum in trace.h, to avoid collisions
 * with the dynamic types.
 *
 * Returns the event type number or zero on error.
 */
int register_ftrace_event(struct trace_event *event)
{
	unsigned key;
	int ret = 0;

646
	down_write(&trace_event_mutex);
647

648
	if (WARN_ON(!event))
649
650
		goto out;

651
652
653
	INIT_LIST_HEAD(&event->list);

	if (!event->type) {
654
		struct list_head *list = NULL;
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673

		if (next_event_type > FTRACE_MAX_EVENT) {

			event->type = trace_search_list(&list);
			if (!event->type)
				goto out;

		} else {
			
			event->type = next_event_type++;
			list = &ftrace_event_list;
		}

		if (WARN_ON(ftrace_find_event(event->type)))
			goto out;

		list_add_tail(&event->list, list);

	} else if (event->type > __TRACE_LAST_TYPE) {
674
675
676
		printk(KERN_WARNING "Need to add type to trace.h\n");
		WARN_ON(1);
		goto out;
677
678
679
680
681
	} else {
		/* Is this event already used */
		if (ftrace_find_event(event->type))
			goto out;
	}
682

683
684
685
686
687
688
689
690
691
	if (event->trace == NULL)
		event->trace = trace_nop_print;
	if (event->raw == NULL)
		event->raw = trace_nop_print;
	if (event->hex == NULL)
		event->hex = trace_nop_print;
	if (event->binary == NULL)
		event->binary = trace_nop_print;

692
693
	key = event->type & (EVENT_HASHSIZE - 1);

694
	hlist_add_head(&event->node, &event_hash[key]);
695
696
697

	ret = event->type;
 out:
698
	up_write(&trace_event_mutex);
699
700
701

	return ret;
}
702
EXPORT_SYMBOL_GPL(register_ftrace_event);
703

704
705
706
707
708
709
710
711
712
713
/*
 * Used by module code with the trace_event_mutex held for write.
 */
int __unregister_ftrace_event(struct trace_event *event)
{
	hlist_del(&event->node);
	list_del(&event->list);
	return 0;
}

714
715
716
717
718
719
/**
 * unregister_ftrace_event - remove a no longer used event
 * @event: the event to remove
 */
int unregister_ftrace_event(struct trace_event *event)
{
720
	down_write(&trace_event_mutex);
721
	__unregister_ftrace_event(event);
722
	up_write(&trace_event_mutex);
723
724
725

	return 0;
}
726
EXPORT_SYMBOL_GPL(unregister_ftrace_event);
727
728
729
730
731

/*
 * Standard events
 */

732
enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags)
733
{
734
	return TRACE_TYPE_HANDLED;
735
736
737
}

/* TRACE_FN */
738
static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags)
739
740
{
	struct ftrace_entry *field;
741
	struct trace_seq *s = &iter->seq;
742

743
	trace_assign_type(field, iter->ent);
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758

	if (!seq_print_ip_sym(s, field->ip, flags))
		goto partial;

	if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) {
		if (!trace_seq_printf(s, " <-"))
			goto partial;
		if (!seq_print_ip_sym(s,
				      field->parent_ip,
				      flags))
			goto partial;
	}
	if (!trace_seq_printf(s, "\n"))
		goto partial;

759
	return TRACE_TYPE_HANDLED;
760
761
762
763
764

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

765
static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags)
766
767
768
{
	struct ftrace_entry *field;

769
	trace_assign_type(field, iter->ent);
770

771
	if (!trace_seq_printf(&iter->seq, "%lx %lx\n",
Lai Jiangshan's avatar
Lai Jiangshan committed
772
773
			      field->ip,
			      field->parent_ip))
774
775
		return TRACE_TYPE_PARTIAL_LINE;

776
	return TRACE_TYPE_HANDLED;
777
778
}

779
static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags)
780
781
{
	struct ftrace_entry *field;
782
	struct trace_seq *s = &iter->seq;
783

784
	trace_assign_type(field, iter->ent);
785
786
787
788

	SEQ_PUT_HEX_FIELD_RET(s, field->ip);
	SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip);

789
	return TRACE_TYPE_HANDLED;
790
791
}

792
static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags)
793
794
{
	struct ftrace_entry *field;
795
	struct trace_seq *s = &iter->seq;
796

797
	trace_assign_type(field, iter->ent);
798
799
800
801

	SEQ_PUT_FIELD_RET(s, field->ip);
	SEQ_PUT_FIELD_RET(s, field->parent_ip);

802
	return TRACE_TYPE_HANDLED;
803
804
805
}

static struct trace_event trace_fn_event = {
806
	.type		= TRACE_FN,
807
808
809
810
811
812
813
	.trace		= trace_fn_trace,
	.raw		= trace_fn_raw,
	.hex		= trace_fn_hex,
	.binary		= trace_fn_bin,
};

/* TRACE_CTX an TRACE_WAKE */
814
815
static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
					     char *delim)
816
817
{
	struct ctx_switch_entry *field;
818
	char comm[TASK_COMM_LEN];
819
820
	int S, T;

821

822
	trace_assign_type(field, iter->ent);
823
824
825

	T = task_state_char(field->next_state);
	S = task_state_char(field->prev_state);
826
	trace_find_cmdline(field->next_pid, comm);
827
828
	if (!trace_seq_printf(&iter->seq,
			      " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
Lai Jiangshan's avatar
Lai Jiangshan committed
829
830
831
832
833
834
835
			      field->prev_pid,
			      field->prev_prio,
			      S, delim,
			      field->next_cpu,
			      field->next_pid,
			      field->next_prio,
			      T, comm))
836
837
		return TRACE_TYPE_PARTIAL_LINE;

838
	return TRACE_TYPE_HANDLED;
839
840
}

841
static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags)
842
{
843
	return trace_ctxwake_print(iter, "==>");
844
845
}

846
847
static enum print_line_t trace_wake_print(struct trace_iterator *iter,
					  int flags)
848
{
849
	return trace_ctxwake_print(iter, "  +");
850
851
}

852
static int trace_ctxwake_raw(struct trace_iterator *iter, char S)
853
854
855
856
{
	struct ctx_switch_entry *field;
	int T;

857
	trace_assign_type(field, iter->ent);
858
859
860
861

	if (!S)
		task_state_char(field->prev_state);
	T = task_state_char(field->next_state);
862
	if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n",
Lai Jiangshan's avatar
Lai Jiangshan committed
863
864
865
866
867
868
869
			      field->prev_pid,
			      field->prev_prio,
			      S,
			      field->next_cpu,
			      field->next_pid,
			      field->next_prio,
			      T))
870
871
		return TRACE_TYPE_PARTIAL_LINE;

872
	return TRACE_TYPE_HANDLED;
873
874
}

875
static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags)
876
{
877
	return trace_ctxwake_raw(iter, 0);
878
879
}

880
static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags)
881
{
882
	return trace_ctxwake_raw(iter, '+');
883
884
885
}


886
static int trace_ctxwake_hex(struct trace_iterator *iter, char S)
887
888
{
	struct ctx_switch_entry *field;
889
	struct trace_seq *s = &iter->seq;
890
891
	int T;

892
	trace_assign_type(field, iter->ent);
893
894
895
896
897
898
899
900
901
902
903
904
905

	if (!S)
		task_state_char(field->prev_state);
	T = task_state_char(field->next_state);

	SEQ_PUT_HEX_FIELD_RET(s, field->prev_pid);
	SEQ_PUT_HEX_FIELD_RET(s, field->prev_prio);
	SEQ_PUT_HEX_FIELD_RET(s, S);
	SEQ_PUT_HEX_FIELD_RET(s, field->next_cpu);
	SEQ_PUT_HEX_FIELD_RET(s, field->next_pid);
	SEQ_PUT_HEX_FIELD_RET(s, field->next_prio);
	SEQ_PUT_HEX_FIELD_RET(s, T);

906
	return TRACE_TYPE_HANDLED;
907
908
}

909
static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags)
910
{
911
	return trace_ctxwake_hex(iter, 0);
912
913
}

914
static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags)
915
{
916
	return trace_ctxwake_hex(iter, '+');
917
918
}

919
920
static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter,
					   int flags)
921
922
{
	struct ctx_switch_entry *field;
923
	struct trace_seq *s = &iter->seq;
924

925
	trace_assign_type(field, iter->ent);
926
927
928
929
930
931
932
933

	SEQ_PUT_FIELD_RET(s, field->prev_pid);
	SEQ_PUT_FIELD_RET(s, field->prev_prio);
	SEQ_PUT_FIELD_RET(s, field->prev_state);
	SEQ_PUT_FIELD_RET(s, field->next_pid);
	SEQ_PUT_FIELD_RET(s, field->next_prio);
	SEQ_PUT_FIELD_RET(s, field->next_state);

934
	return TRACE_TYPE_HANDLED;
935
936
937
}

static struct trace_event trace_ctx_event = {
938
	.type		= TRACE_CTX,
939
940
941
942
943
944
945
	.trace		= trace_ctx_print,
	.raw		= trace_ctx_raw,
	.hex		= trace_ctx_hex,
	.binary		= trace_ctxwake_bin,
};

static struct trace_event trace_wake_event = {
946
	.type		= TRACE_WAKE,
947
948
949
950
951
952
953
	.trace		= trace_wake_print,
	.raw		= trace_wake_raw,
	.hex		= trace_wake_hex,
	.binary		= trace_ctxwake_bin,
};

/* TRACE_SPECIAL */
954
955
static enum print_line_t trace_special_print(struct trace_iterator *iter,
					     int flags)
956
957
958
{
	struct special_entry *field;

959
	trace_assign_type(field, iter->ent);
960

961
	if (!trace_seq_printf(&iter->seq, "# %ld %ld %ld\n",
Lai Jiangshan's avatar
Lai Jiangshan committed
962
963
964
			      field->arg1,
			      field->arg2,
			      field->arg3))
965
966
		return TRACE_TYPE_PARTIAL_LINE;

967
	return TRACE_TYPE_HANDLED;
968
969
}

970
971
static enum print_line_t trace_special_hex(struct trace_iterator *iter,
					   int flags)
972
973
{
	struct special_entry *field;
974
	struct trace_seq *s = &iter->seq;
975

976
	trace_assign_type(field, iter->ent);
977
978
979
980
981

	SEQ_PUT_HEX_FIELD_RET(s, field->arg1);
	SEQ_PUT_HEX_FIELD_RET(s, field->arg2);
	SEQ_PUT_HEX_FIELD_RET(s, field->arg3);

982
	return TRACE_TYPE_HANDLED;
983
984
}

985
986
static enum print_line_t trace_special_bin(struct trace_iterator *iter,
					   int flags)
987
988
{
	struct special_entry *field;
989
	struct trace_seq *s = &iter->seq;
990

991
	trace_assign_type(field, iter->ent);
992
993
994
995
996

	SEQ_PUT_FIELD_RET(s, field->arg1);
	SEQ_PUT_FIELD_RET(s, field->arg2);
	SEQ_PUT_FIELD_RET(s, field->arg3);

997
	return TRACE_TYPE_HANDLED;
998
999
1000
}

static struct trace_event trace_special_event = {
1001
	.type		= TRACE_SPECIAL,
1002
1003
1004
1005
1006
1007
1008
1009
	.trace		= trace_special_print,
	.raw		= trace_special_print,
	.hex		= trace_special_hex,
	.binary		= trace_special_bin,
};

/* TRACE_STACK */

1010
1011
static enum print_line_t trace_stack_print(struct trace_iterator *iter,
					   int flags)
1012
1013
{
	struct stack_entry *field;
1014
	struct trace_seq *s = &iter->seq;
1015
1016
	int i;

1017
	trace_assign_type(field, iter->ent);
1018

1019
	if (!trace_seq_puts(s, "<stack trace>\n"))
1020
		goto partial;
1021
	for (i = 0; i < FTRACE_STACK_ENTRIES; i++) {
1022
		if (!field->caller[i] || (field->caller[i] == ULONG_MAX))
1023
			break;
1024
1025
		if (!trace_seq_puts(s, " => "))
			goto partial;
1026

1027
1028
		if (!seq_print_ip_sym(s, field->caller[i], flags))
			goto partial;
Lai Jiangshan's avatar
Lai Jiangshan committed
1029
		if (!trace_seq_puts(s, "\n"))
1030
1031
1032
			goto partial;
	}

1033
	return TRACE_TYPE_HANDLED;
1034
1035
1036
1037
1038
1039

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

static struct trace_event trace_stack_event = {
1040
	.type		= TRACE_STACK,
1041
1042
1043
1044
1045
1046
1047
	.trace		= trace_stack_print,
	.raw		= trace_special_print,
	.hex		= trace_special_hex,
	.binary		= trace_special_bin,
};

/* TRACE_USER_STACK */
1048
1049
static enum print_line_t trace_user_stack_print(struct trace_iterator *iter,
						int flags)
1050
1051
{
	struct userstack_entry *field;
1052
	struct trace_seq *s = &iter->seq;
1053

1054
	trace_assign_type(field, iter->ent);
1055

1056
	if (!trace_seq_puts(s, "<user stack trace>\n"))
1057
1058
		goto partial;

1059
	if (!seq_print_userip_objs(field, s, flags))
1060
1061
		goto partial;

1062
	return TRACE_TYPE_HANDLED;
1063
1064
1065
1066
1067
1068

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

static struct trace_event trace_user_stack_event = {
1069
	.type		= TRACE_USER_STACK,
1070
1071
1072
1073
1074
1075
	.trace		= trace_user_stack_print,
	.raw		= trace_special_print,
	.hex		= trace_special_hex,
	.binary		= trace_special_bin,
};

1076
/* TRACE_BPRINT */
1077
static enum print_line_t
1078
trace_bprint_print(struct trace_iterator *iter, int flags)
1079
1080
1081
{
	struct trace_entry *entry = iter->ent;
	struct trace_seq *s = &iter->seq;
1082
	struct bprint_entry *field;
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100

	trace_assign_type(field, entry);

	if (!seq_print_ip_sym(s, field->ip, flags))
		goto partial;

	if (!trace_seq_puts(s, ": "))
		goto partial;

	if (!trace_seq_bprintf(s, field->fmt, field->buf))
		goto partial;

	return TRACE_TYPE_HANDLED;

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

1101

1102
1103
static enum print_line_t
trace_bprint_raw(struct trace_iterator *iter, int flags)
1104
{
1105
	struct bprint_entry *field;
1106
1107
	struct trace_seq *s = &iter->seq;

1108
	trace_assign_type(field, iter->ent);
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121

	if (!trace_seq_printf(s, ": %lx : ", field->ip))
		goto partial;

	if (!trace_seq_bprintf(s, field->fmt, field->buf))
		goto partial;

	return TRACE_TYPE_HANDLED;

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

1122

1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
static struct trace_event trace_bprint_event = {
	.type		= TRACE_BPRINT,
	.trace		= trace_bprint_print,
	.raw		= trace_bprint_raw,
};

/* TRACE_PRINT */
static enum print_line_t trace_print_print(struct trace_iterator *iter,
					   int flags)
{
	struct print_entry *field;
	struct trace_seq *s = &iter->seq;

	trace_assign_type(field, iter->ent);

	if (!seq_print_ip_sym(s, field->ip, flags))
		goto partial;

	if (!trace_seq_printf(s, ": %s", field->buf))
		goto partial;

	return TRACE_TYPE_HANDLED;

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags)
{
	struct print_entry *field;

	trace_assign_type(field, iter->ent);

	if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf))
		goto partial;

	return TRACE_TYPE_HANDLED;

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

1165
static struct trace_event trace_print_event = {
1166
	.type	 	= TRACE_PRINT,
1167
1168
	.trace		= trace_print_print,
	.raw		= trace_print_raw,
1169
1170
};

1171

1172
1173
1174
1175
1176
1177
1178
static struct trace_event *events[] __initdata = {
	&trace_fn_event,
	&trace_ctx_event,
	&trace_wake_event,
	&trace_special_event,
	&trace_stack_event,
	&trace_user_stack_event,
1179
	&trace_bprint_event,
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
	&trace_print_event,
	NULL
};

__init static int init_events(void)
{
	struct trace_event *event;
	int i, ret;

	for (i = 0; events[i]; i++) {
		event = events[i];

		ret = register_ftrace_event(event);
		if (!ret) {
			printk(KERN_WARNING "event %d failed to register\n",
			       event->type);
			WARN_ON_ONCE(1);
		}
	}

	return 0;
}
device_initcall(init_events);