trace_functions_graph.c 20.7 KB
Newer Older
1
2
3
/*
 *
 * Function graph tracer.
4
 * Copyright (c) 2008-2009 Frederic Weisbecker <fweisbec@gmail.com>
5
6
7
8
9
10
11
12
13
14
 * Mostly borrowed from function tracer which
 * is Copyright (c) Steven Rostedt <srostedt@redhat.com>
 *
 */
#include <linux/debugfs.h>
#include <linux/uaccess.h>
#include <linux/ftrace.h>
#include <linux/fs.h>

#include "trace.h"
15
#include "trace_output.h"
16

17
18
19
20
21
struct fgraph_data {
	pid_t		last_pid;
	int		depth;
};

22
#define TRACE_GRAPH_INDENT	2
23

24
/* Flag options */
25
#define TRACE_GRAPH_PRINT_OVERRUN	0x1
26
27
#define TRACE_GRAPH_PRINT_CPU		0x2
#define TRACE_GRAPH_PRINT_OVERHEAD	0x4
28
#define TRACE_GRAPH_PRINT_PROC		0x8
29
30
#define TRACE_GRAPH_PRINT_DURATION	0x10
#define TRACE_GRAPH_PRINT_ABS_TIME	0X20
31

32
static struct tracer_opt trace_opts[] = {
33
	/* Display overruns? (for self-debug purpose) */
34
35
36
37
38
	{ TRACER_OPT(funcgraph-overrun, TRACE_GRAPH_PRINT_OVERRUN) },
	/* Display CPU ? */
	{ TRACER_OPT(funcgraph-cpu, TRACE_GRAPH_PRINT_CPU) },
	/* Display Overhead ? */
	{ TRACER_OPT(funcgraph-overhead, TRACE_GRAPH_PRINT_OVERHEAD) },
39
40
	/* Display proc name/pid */
	{ TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
41
42
43
44
	/* Display duration of execution */
	{ TRACER_OPT(funcgraph-duration, TRACE_GRAPH_PRINT_DURATION) },
	/* Display absolute time of an entry */
	{ TRACER_OPT(funcgraph-abstime, TRACE_GRAPH_PRINT_ABS_TIME) },
45
46
47
48
	{ } /* Empty entry */
};

static struct tracer_flags tracer_flags = {
49
	/* Don't display overruns and proc by default */
50
51
	.val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD |
	       TRACE_GRAPH_PRINT_DURATION,
52
53
54
	.opts = trace_opts
};

55
/* pid on the last trace processed */
56

57

58
59
/* Add a function return address to the trace stack on thread info.*/
int
60
ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth)
61
{
62
	unsigned long long calltime;
63
64
65
66
67
68
69
70
71
72
73
	int index;

	if (!current->ret_stack)
		return -EBUSY;

	/* The return trace stack is full */
	if (current->curr_ret_stack == FTRACE_RETFUNC_DEPTH - 1) {
		atomic_inc(&current->trace_overrun);
		return -EBUSY;
	}

74
75
	calltime = trace_clock_local();

76
77
78
79
	index = ++current->curr_ret_stack;
	barrier();
	current->ret_stack[index].ret = ret;
	current->ret_stack[index].func = func;
80
	current->ret_stack[index].calltime = calltime;
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
	*depth = index;

	return 0;
}

/* Retrieve a function return address to the trace stack on thread info.*/
void
ftrace_pop_return_trace(struct ftrace_graph_ret *trace, unsigned long *ret)
{
	int index;

	index = current->curr_ret_stack;

	if (unlikely(index < 0)) {
		ftrace_graph_stop();
		WARN_ON(1);
		/* Might as well panic, otherwise we have no where to go */
		*ret = (unsigned long)panic;
		return;
	}

	*ret = current->ret_stack[index].ret;
	trace->func = current->ret_stack[index].func;
	trace->calltime = current->ret_stack[index].calltime;
	trace->overrun = atomic_read(&current->trace_overrun);
	trace->depth = index;
	barrier();
	current->curr_ret_stack--;

}

/*
 * Send the trace to the ring-buffer.
 * @return the original return address.
 */
unsigned long ftrace_return_to_handler(void)
{
	struct ftrace_graph_ret trace;
	unsigned long ret;

	ftrace_pop_return_trace(&trace, &ret);
122
	trace.rettime = trace_clock_local();
123
124
125
126
127
128
129
130
131
132
133
134
	ftrace_graph_return(&trace);

	if (unlikely(!ret)) {
		ftrace_graph_stop();
		WARN_ON(1);
		/* Might as well panic. What else to do? */
		ret = (unsigned long)panic;
	}

	return ret;
}

135
136
static int graph_trace_init(struct trace_array *tr)
{
137
	int ret = register_ftrace_graph(&trace_graph_return,
138
					&trace_graph_entry);
139
140
141
142
143
	if (ret)
		return ret;
	tracing_start_cmdline_record();

	return 0;
144
145
146
147
}

static void graph_trace_reset(struct trace_array *tr)
{
148
149
	tracing_stop_cmdline_record();
	unregister_ftrace_graph();
150
151
}

152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
static inline int log10_cpu(int nb)
{
	if (nb / 100)
		return 3;
	if (nb / 10)
		return 2;
	return 1;
}

static enum print_line_t
print_graph_cpu(struct trace_seq *s, int cpu)
{
	int i;
	int ret;
	int log10_this = log10_cpu(cpu);
167
	int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
168
169


170
171
172
173
174
175
176
177
178
179
180
181
182
	/*
	 * Start with a space character - to make it stand out
	 * to the right a bit when trace output is pasted into
	 * email:
	 */
	ret = trace_seq_printf(s, " ");

	/*
	 * Tricky - we space the CPU field according to the max
	 * number of online CPUs. On a 2-cpu system it would take
	 * a maximum of 1 digit - on a 128 cpu system it would
	 * take up to 3 digits:
	 */
183
184
185
186
187
188
189
	for (i = 0; i < log10_all - log10_this; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
	ret = trace_seq_printf(s, "%d) ", cpu);
	if (!ret)
190
191
		return TRACE_TYPE_PARTIAL_LINE;

192
193
194
	return TRACE_TYPE_HANDLED;
}

195
196
197
198
199
#define TRACE_GRAPH_PROCINFO_LENGTH	14

static enum print_line_t
print_graph_proc(struct trace_seq *s, pid_t pid)
{
200
	char comm[TASK_COMM_LEN];
201
202
	/* sign + log10(MAX_INT) + '\0' */
	char pid_str[11];
203
204
205
206
	int spaces = 0;
	int ret;
	int len;
	int i;
207

208
	trace_find_cmdline(pid, comm);
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
	comm[7] = '\0';
	sprintf(pid_str, "%d", pid);

	/* 1 stands for the "-" character */
	len = strlen(comm) + strlen(pid_str) + 1;

	if (len < TRACE_GRAPH_PROCINFO_LENGTH)
		spaces = TRACE_GRAPH_PROCINFO_LENGTH - len;

	/* First spaces to align center */
	for (i = 0; i < spaces / 2; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = trace_seq_printf(s, "%s-%s", comm, pid_str);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Last spaces to align center */
	for (i = 0; i < spaces - (spaces / 2); i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
	return TRACE_TYPE_HANDLED;
}

238

239
/* If the pid changed since the last trace, output this event */
240
static enum print_line_t
241
verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
242
{
243
	pid_t prev_pid;
244
	pid_t *last_pid;
245
	int ret;
246

247
	if (!data)
248
249
		return TRACE_TYPE_HANDLED;

250
	last_pid = &(per_cpu_ptr(data, cpu)->last_pid);
251
252

	if (*last_pid == pid)
253
		return TRACE_TYPE_HANDLED;
254

255
256
	prev_pid = *last_pid;
	*last_pid = pid;
257

258
259
	if (prev_pid == -1)
		return TRACE_TYPE_HANDLED;
260
261
262
263
264
265
266
267
268
/*
 * Context-switch trace line:

 ------------------------------------------
 | 1)  migration/0--1  =>  sshd-1755
 ------------------------------------------

 */
	ret = trace_seq_printf(s,
269
		" ------------------------------------------\n");
270
	if (!ret)
271
		return TRACE_TYPE_PARTIAL_LINE;
272
273
274

	ret = print_graph_cpu(s, cpu);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
275
		return TRACE_TYPE_PARTIAL_LINE;
276
277
278

	ret = print_graph_proc(s, prev_pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
279
		return TRACE_TYPE_PARTIAL_LINE;
280
281
282

	ret = trace_seq_printf(s, " => ");
	if (!ret)
283
		return TRACE_TYPE_PARTIAL_LINE;
284
285
286

	ret = print_graph_proc(s, pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
287
		return TRACE_TYPE_PARTIAL_LINE;
288
289
290
291

	ret = trace_seq_printf(s,
		"\n ------------------------------------------\n\n");
	if (!ret)
292
		return TRACE_TYPE_PARTIAL_LINE;
293

294
	return TRACE_TYPE_HANDLED;
295
296
}

297
298
static struct ftrace_graph_ret_entry *
get_return_for_leaf(struct trace_iterator *iter,
299
300
301
302
303
304
305
306
		struct ftrace_graph_ent_entry *curr)
{
	struct ring_buffer_iter *ring_iter;
	struct ring_buffer_event *event;
	struct ftrace_graph_ret_entry *next;

	ring_iter = iter->buffer_iter[iter->cpu];

307
308
309
310
311
312
313
314
315
	/* First peek to compare current entry and the next one */
	if (ring_iter)
		event = ring_buffer_iter_peek(ring_iter, NULL);
	else {
	/* We need to consume the current entry to see the next one */
		ring_buffer_consume(iter->tr->buffer, iter->cpu, NULL);
		event = ring_buffer_peek(iter->tr->buffer, iter->cpu,
					NULL);
	}
316
317

	if (!event)
318
		return NULL;
319
320
321
322

	next = ring_buffer_event_data(event);

	if (next->ent.type != TRACE_GRAPH_RET)
323
		return NULL;
324
325
326

	if (curr->ent.pid != next->ent.pid ||
			curr->graph_ent.func != next->ret.func)
327
		return NULL;
328

329
330
331
332
333
	/* this is a leaf, now advance the iterator */
	if (ring_iter)
		ring_buffer_read(ring_iter, NULL);

	return next;
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
/* Signal a overhead of time execution to the output */
static int
print_graph_overhead(unsigned long long duration, struct trace_seq *s)
{
	/* If duration disappear, we don't need anything */
	if (!(tracer_flags.val & TRACE_GRAPH_PRINT_DURATION))
		return 1;

	/* Non nested entry or return */
	if (duration == -1)
		return trace_seq_printf(s, "  ");

	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
		/* Duration exceeded 100 msecs */
		if (duration > 100000ULL)
			return trace_seq_printf(s, "! ");

		/* Duration exceeded 10 msecs */
		if (duration > 10000ULL)
			return trace_seq_printf(s, "+ ");
	}

	return trace_seq_printf(s, "  ");
}

361
362
363
364
365
366
367
368
369
370
371
static int print_graph_abs_time(u64 t, struct trace_seq *s)
{
	unsigned long usecs_rem;

	usecs_rem = do_div(t, NSEC_PER_SEC);
	usecs_rem /= 1000;

	return trace_seq_printf(s, "%5lu.%06lu |  ",
			(unsigned long)t, usecs_rem);
}

372
static enum print_line_t
373
print_graph_irq(struct trace_iterator *iter, unsigned long addr,
374
		enum trace_type type, int cpu, pid_t pid)
375
376
{
	int ret;
377
	struct trace_seq *s = &iter->seq;
378
379
380
381
382

	if (addr < (unsigned long)__irqentry_text_start ||
		addr >= (unsigned long)__irqentry_text_end)
		return TRACE_TYPE_UNHANDLED;

383
384
385
386
387
388
389
	/* Absolute time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
		ret = print_graph_abs_time(iter->ts, s);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
	/* Cpu */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
		ret = print_graph_cpu(s, cpu);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}
	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
		ret = print_graph_proc(s, pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
		ret = trace_seq_printf(s, " | ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
405

406
407
408
409
	/* No overhead */
	ret = print_graph_overhead(-1, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
410

411
412
413
414
415
416
417
418
419
420
421
422
	if (type == TRACE_GRAPH_ENT)
		ret = trace_seq_printf(s, "==========>");
	else
		ret = trace_seq_printf(s, "<==========");

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Don't close the duration column if haven't one */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
		trace_seq_printf(s, " |");
	ret = trace_seq_printf(s, "\n");
423
424
425
426
427

	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
	return TRACE_TYPE_HANDLED;
}
428

429
static enum print_line_t
430
431
432
print_graph_duration(unsigned long long duration, struct trace_seq *s)
{
	unsigned long nsecs_rem = do_div(duration, 1000);
433
434
435
436
437
438
439
440
441
	/* log10(ULONG_MAX) + '\0' */
	char msecs_str[21];
	char nsecs_str[5];
	int ret, len;
	int i;

	sprintf(msecs_str, "%lu", (unsigned long) duration);

	/* Print msecs */
442
	ret = trace_seq_printf(s, "%s", msecs_str);
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	len = strlen(msecs_str);

	/* Print nsecs (we don't want to exceed 7 numbers) */
	if (len < 7) {
		snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem);
		ret = trace_seq_printf(s, ".%s", nsecs_str);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
		len += strlen(nsecs_str);
	}

	ret = trace_seq_printf(s, " us ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* Print remaining spaces to fit the row's width */
	for (i = len; i < 7; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = trace_seq_printf(s, "|  ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
	return TRACE_TYPE_HANDLED;

473
474
475
}

/* Case of a leaf function on its call entry */
476
static enum print_line_t
477
print_graph_entry_leaf(struct trace_iterator *iter,
478
479
		struct ftrace_graph_ent_entry *entry,
		struct ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
480
{
481
	struct fgraph_data *data = iter->private;
482
483
484
	struct ftrace_graph_ret *graph_ret;
	struct ftrace_graph_ent *call;
	unsigned long long duration;
485
	int ret;
486
	int i;
487

488
489
490
491
	graph_ret = &ret_entry->ret;
	call = &entry->graph_ent;
	duration = graph_ret->rettime - graph_ret->calltime;

492
493
494
495
496
497
498
499
500
501
502
503
	if (data) {
		int cpu = iter->cpu;
		int *depth = &(per_cpu_ptr(data, cpu)->depth);

		/*
		 * Comments display at + 1 to depth. Since
		 * this is a leaf function, keep the comments
		 * equal to this depth.
		 */
		*depth = call->depth - 1;
	}

504
	/* Overhead */
505
506
507
	ret = print_graph_overhead(duration, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
508
509

	/* Duration */
510
511
512
513
514
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
		ret = print_graph_duration(duration, s);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}
515

516
517
518
519
520
521
522
523
524
525
526
	/* Function */
	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	ret = seq_print_ip_sym(s, call->func, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

527
	ret = trace_seq_printf(s, "();\n");
528
529
530
531
532
533
534
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
535
536
537
print_graph_entry_nested(struct trace_iterator *iter,
			 struct ftrace_graph_ent_entry *entry,
			 struct trace_seq *s, int cpu)
538
539
{
	struct ftrace_graph_ent *call = &entry->graph_ent;
540
541
542
543
544
545
546
547
548
549
	struct fgraph_data *data = iter->private;
	int ret;
	int i;

	if (data) {
		int cpu = iter->cpu;
		int *depth = &(per_cpu_ptr(data, cpu)->depth);

		*depth = call->depth;
	}
550
551

	/* No overhead */
552
553
554
	ret = print_graph_overhead(-1, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
555

556
557
	/* No time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
558
559
560
561
562
		ret = trace_seq_printf(s, "            |  ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

563
	/* Function */
564
565
	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
566
567
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
568
569
570
571
572
573
	}

	ret = seq_print_ip_sym(s, call->func, 0);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

574
	ret = trace_seq_printf(s, "() {\n");
575
576
577
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

578
579
580
581
582
	/*
	 * we already consumed the current entry to check the next one
	 * and see if this is a leaf.
	 */
	return TRACE_TYPE_NO_CONSUME;
583
584
}

585
static enum print_line_t
586
587
print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
		     int type, unsigned long addr)
588
{
589
	struct fgraph_data *data = iter->private;
590
	struct trace_entry *ent = iter->ent;
591
592
	int cpu = iter->cpu;
	int ret;
593

594
	/* Pid */
595
	if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE)
596
597
		return TRACE_TYPE_PARTIAL_LINE;

598
599
600
601
602
603
	if (type) {
		/* Interrupt */
		ret = print_graph_irq(iter, addr, type, cpu, ent->pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}
604

605
606
607
608
609
610
611
	/* Absolute time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME) {
		ret = print_graph_abs_time(iter->ts, s);
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

612
613
614
	/* Cpu */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
		ret = print_graph_cpu(s, cpu);
615
616
617
618
619
620
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
621
		ret = print_graph_proc(s, ent->pid);
622
623
624
625
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;

		ret = trace_seq_printf(s, " | ");
626
627
628
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
629

630
631
632
633
634
635
636
637
638
639
640
641
642
643
	return 0;
}

static enum print_line_t
print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
			struct trace_iterator *iter)
{
	int cpu = iter->cpu;
	struct ftrace_graph_ent *call = &field->graph_ent;
	struct ftrace_graph_ret_entry *leaf_ret;

	if (print_graph_prologue(iter, s, TRACE_GRAPH_ENT, call->func))
		return TRACE_TYPE_PARTIAL_LINE;

644
645
646
	leaf_ret = get_return_for_leaf(iter, field);
	if (leaf_ret)
		return print_graph_entry_leaf(iter, field, leaf_ret, s);
647
	else
648
		return print_graph_entry_nested(iter, field, s, cpu);
649
650
651

}

652
653
static enum print_line_t
print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
654
		   struct trace_entry *ent, struct trace_iterator *iter)
655
{
656
	unsigned long long duration = trace->rettime - trace->calltime;
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
	struct fgraph_data *data = iter->private;
	pid_t pid = ent->pid;
	int cpu = iter->cpu;
	int ret;
	int i;

	if (data) {
		int cpu = iter->cpu;
		int *depth = &(per_cpu_ptr(data, cpu)->depth);

		/*
		 * Comments display at + 1 to depth. This is the
		 * return from a function, we now want the comments
		 * to display at the same level of the bracket.
		 */
		*depth = trace->depth - 1;
	}
674

675
	if (print_graph_prologue(iter, s, 0, 0))
676
677
		return TRACE_TYPE_PARTIAL_LINE;

678
	/* Overhead */
679
680
681
	ret = print_graph_overhead(duration, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
682
683

	/* Duration */
684
685
686
687
688
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
		ret = print_graph_duration(duration, s);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}
689
690

	/* Closing brace */
691
692
	for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
693
694
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
695
696
	}

697
	ret = trace_seq_printf(s, "}\n");
698
699
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
700

701
	/* Overrun */
702
703
704
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
		ret = trace_seq_printf(s, " (Overruns: %lu)\n",
					trace->overrun);
705
706
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
707
	}
708

709
	ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);
710
711
712
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

713
714
715
	return TRACE_TYPE_HANDLED;
}

716
static enum print_line_t
717
718
print_graph_comment(struct trace_seq *s,  struct trace_entry *ent,
		    struct trace_iterator *iter)
719
{
720
	unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
721
	struct fgraph_data *data = iter->private;
722
	struct trace_event *event;
723
	int depth = 0;
724
	int ret;
725
726
727
728
	int i;

	if (data)
		depth = per_cpu_ptr(data, iter->cpu)->depth;
729

730
	if (print_graph_prologue(iter, s, 0, 0))
731
732
		return TRACE_TYPE_PARTIAL_LINE;

733
	/* No overhead */
734
735
736
737
738
739
740
	ret = print_graph_overhead(-1, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	/* No time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
		ret = trace_seq_printf(s, "            |  ");
741
742
743
744
745
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Indentation */
746
747
	if (depth > 0)
		for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) {
748
749
750
751
752
753
			ret = trace_seq_printf(s, " ");
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}

	/* The comment */
754
755
756
757
	ret = trace_seq_printf(s, "/* ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
	switch (iter->ent->type) {
	case TRACE_BPRINT:
		ret = trace_print_bprintk_msg_only(iter);
		if (ret != TRACE_TYPE_HANDLED)
			return ret;
		break;
	case TRACE_PRINT:
		ret = trace_print_printk_msg_only(iter);
		if (ret != TRACE_TYPE_HANDLED)
			return ret;
		break;
	default:
		event = ftrace_find_event(ent->type);
		if (!event)
			return TRACE_TYPE_UNHANDLED;

		ret = event->trace(iter, sym_flags);
		if (ret != TRACE_TYPE_HANDLED)
			return ret;
	}
778

779
780
781
782
783
784
	/* Strip ending newline */
	if (s->buffer[s->len - 1] == '\n') {
		s->buffer[s->len - 1] = '\0';
		s->len--;
	}

785
786
787
788
789
790
791
792
	ret = trace_seq_printf(s, " */\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}


793
794
795
796
enum print_line_t
print_graph_function(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
797
	struct trace_seq *s = &iter->seq;
798

799
800
801
802
	switch (entry->type) {
	case TRACE_GRAPH_ENT: {
		struct ftrace_graph_ent_entry *field;
		trace_assign_type(field, entry);
803
		return print_graph_entry(field, s, iter);
804
805
806
807
	}
	case TRACE_GRAPH_RET: {
		struct ftrace_graph_ret_entry *field;
		trace_assign_type(field, entry);
808
		return print_graph_return(&field->ret, s, entry, iter);
809
810
	}
	default:
811
		return print_graph_comment(s, entry, iter);
812
	}
813
814

	return TRACE_TYPE_HANDLED;
815
816
}

817
818
819
820
static void print_graph_headers(struct seq_file *s)
{
	/* 1st line */
	seq_printf(s, "# ");
821
822
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
		seq_printf(s, "     TIME       ");
823
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
824
		seq_printf(s, "CPU");
825
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
826
827
828
829
		seq_printf(s, "  TASK/PID      ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
		seq_printf(s, "  DURATION   ");
	seq_printf(s, "               FUNCTION CALLS\n");
830
831
832

	/* 2nd line */
	seq_printf(s, "# ");
833
834
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
		seq_printf(s, "      |         ");
835
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
836
		seq_printf(s, "|  ");
837
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
838
839
840
841
		seq_printf(s, "  |    |        ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
		seq_printf(s, "   |   |      ");
	seq_printf(s, "               |   |   |   |\n");
842
}
843
844
845

static void graph_trace_open(struct trace_iterator *iter)
{
846
847
	/* pid and depth on the last trace processed */
	struct fgraph_data *data = alloc_percpu(struct fgraph_data);
848
849
	int cpu;

850
	if (!data)
851
852
853
		pr_warning("function graph tracer: not enough memory\n");
	else
		for_each_possible_cpu(cpu) {
854
855
			pid_t *pid = &(per_cpu_ptr(data, cpu)->last_pid);
			int *depth = &(per_cpu_ptr(data, cpu)->depth);
856
			*pid = -1;
857
			*depth = 0;
858
859
		}

860
	iter->private = data;
861
862
863
864
}

static void graph_trace_close(struct trace_iterator *iter)
{
865
	free_percpu(iter->private);
866
867
}

868
static struct tracer graph_trace __read_mostly = {
869
	.name		= "function_graph",
870
871
	.open		= graph_trace_open,
	.close		= graph_trace_close,
872
	.wait_pipe	= poll_wait_pipe,
873
874
	.init		= graph_trace_init,
	.reset		= graph_trace_reset,
875
876
	.print_line	= print_graph_function,
	.print_header	= print_graph_headers,
877
	.flags		= &tracer_flags,
878
879
880
#ifdef CONFIG_FTRACE_SELFTEST
	.selftest	= trace_selftest_startup_function_graph,
#endif
881
882
883
884
885
886
887
888
};

static __init int init_graph_trace(void)
{
	return register_tracer(&graph_trace);
}

device_initcall(init_graph_trace);