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
30
31
32
33
34
35
void trace_print_seq(struct seq_file *m, struct trace_seq *s)
{
	int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;

	s->buffer[len] = 0;
	seq_puts(m, s->buffer);

	trace_seq_init(s);
}

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
67
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;
}

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
100
/**
 * 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;
}
101
EXPORT_SYMBOL_GPL(trace_seq_printf);
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
134
/**
 * 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);

135
int trace_seq_bprintf(struct trace_seq *s, const char *fmt, const u32 *binary)
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
{
	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;
}

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
186
/**
 * 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;
}

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

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

	return len;
}

198
int trace_seq_putmem_hex(struct trace_seq *s, const void *mem, size_t len)
199
200
{
	unsigned char hex[HEX_CHARS];
201
	const unsigned char *data = mem;
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
	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);
}

217
218
219
220
221
222
223
224
225
226
227
228
229
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;
}

230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
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;
}

251
252
253
254
255
256
257
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;
258
	const char *ret = p->buffer + p->len;
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
	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);

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

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

	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);

308
	return ret;
309
}
310
EXPORT_SYMBOL(ftrace_print_symbols_seq);
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
410
411
412
413
414
415
416
417
418
419
420
421
#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();
		task = find_task_by_vpid(entry->ent.tgid);
		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;
422
423
		if (ret)
			ret = trace_seq_puts(s, " => ");
424
425
426
		if (!ip) {
			if (ret)
				ret = trace_seq_puts(s, "??");
427
428
			if (ret)
				ret = trace_seq_puts(s, "\n");
429
430
431
432
433
434
			continue;
		}
		if (!ret)
			break;
		if (ret)
			ret = seq_print_user_ip(s, mm, ip, sym_flags);
435
		ret = trace_seq_puts(s, "\n");
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
463
	}

	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;
}

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

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

	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;
484
485

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

static unsigned long preempt_mark_thresh = 100;

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

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;
508
509
510
	char comm[TASK_COMM_LEN];

	trace_find_cmdline(entry->pid, comm);
511

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

int trace_print_lat_context(struct trace_iterator *iter)
{
	u64 next_ts;
519
	int ret;
520
521
522
523
524
525
526
527
528
529
530
531
532
	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) {
533
534
535
536
		char comm[TASK_COMM_LEN];

		trace_find_cmdline(entry->pid, comm);

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

552
	return ret;
553
554
}

555
556
557
558
559
560
561
562
563
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] : '?';
}

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

	key = type & (EVENT_HASHSIZE - 1);

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

	return NULL;
}

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
616
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;
}

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

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

627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
/**
 * 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;

647
	down_write(&trace_event_mutex);
648

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

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

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

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

684
685
686
687
688
689
690
691
692
	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;

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

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

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

	return ret;
}
703
EXPORT_SYMBOL_GPL(register_ftrace_event);
704

705
706
707
708
709
710
711
712
713
714
/*
 * 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;
}

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

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

/*
 * Standard events
 */

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

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

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

	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;

760
	return TRACE_TYPE_HANDLED;
761
762
763
764
765

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

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

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

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

777
	return TRACE_TYPE_HANDLED;
778
779
}

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

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

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

790
	return TRACE_TYPE_HANDLED;
791
792
}

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

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

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

803
	return TRACE_TYPE_HANDLED;
804
805
806
}

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

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

822

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

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

839
	return TRACE_TYPE_HANDLED;
840
841
}

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

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

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

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

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

873
	return TRACE_TYPE_HANDLED;
874
875
}

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

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


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

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

	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);

907
	return TRACE_TYPE_HANDLED;
908
909
}

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

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

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

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

	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);

935
	return TRACE_TYPE_HANDLED;
936
937
938
}

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

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

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

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

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

968
	return TRACE_TYPE_HANDLED;
969
970
}

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

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

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

983
	return TRACE_TYPE_HANDLED;
984
985
}

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

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

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

998
	return TRACE_TYPE_HANDLED;
999
1000
1001
}

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

/* TRACE_STACK */

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

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

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

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

1034
	return TRACE_TYPE_HANDLED;
1035
1036
1037
1038
1039
1040

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

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

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

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

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

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

1063
	return TRACE_TYPE_HANDLED;
1064
1065
1066
1067
1068
1069

 partial:
	return TRACE_TYPE_PARTIAL_LINE;
}

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

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

	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;
}

1102

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

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

	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;
}

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
1165
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;
}

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

1172

1173
1174
1175
1176
1177
1178
1179
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,
1180
	&trace_bprint_event,
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
	&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);