trace_functions_graph.c 21 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
	int index;

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

68 69 70 71 72 73
	/*
	 * We must make sure the ret_stack is tested before we read
	 * anything else.
	 */
	smp_rmb();

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

80 81
	calltime = trace_clock_local();

82 83 84 85
	index = ++current->curr_ret_stack;
	barrier();
	current->ret_stack[index].ret = ret;
	current->ret_stack[index].func = func;
86
	current->ret_stack[index].calltime = calltime;
87
	current->ret_stack[index].subtime = 0;
88 89 90 91 92 93
	*depth = index;

	return 0;
}

/* Retrieve a function return address to the trace stack on thread info.*/
94
static void
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 122 123 124 125
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;
}

/*
 * 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);
126
	trace.rettime = trace_clock_local();
127
	ftrace_graph_return(&trace);
128 129
	barrier();
	current->curr_ret_stack--;
130 131 132 133 134 135 136 137 138 139 140

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

	return ret;
}

141 142
static int graph_trace_init(struct trace_array *tr)
{
143
	int ret = register_ftrace_graph(&trace_graph_return,
144
					&trace_graph_entry);
145 146 147 148 149
	if (ret)
		return ret;
	tracing_start_cmdline_record();

	return 0;
150 151 152 153
}

static void graph_trace_reset(struct trace_array *tr)
{
154 155
	tracing_stop_cmdline_record();
	unregister_ftrace_graph();
156 157
}

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
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);
173
	int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
174 175


176 177 178 179 180 181 182 183 184 185 186 187 188
	/*
	 * 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:
	 */
189 190 191 192 193 194 195
	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)
196 197
		return TRACE_TYPE_PARTIAL_LINE;

198 199 200
	return TRACE_TYPE_HANDLED;
}

201 202 203 204 205
#define TRACE_GRAPH_PROCINFO_LENGTH	14

static enum print_line_t
print_graph_proc(struct trace_seq *s, pid_t pid)
{
206
	char comm[TASK_COMM_LEN];
207 208
	/* sign + log10(MAX_INT) + '\0' */
	char pid_str[11];
209 210 211 212
	int spaces = 0;
	int ret;
	int len;
	int i;
213

214
	trace_find_cmdline(pid, comm);
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
	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;
}

244

245
/* If the pid changed since the last trace, output this event */
246
static enum print_line_t
247
verif_pid(struct trace_seq *s, pid_t pid, int cpu, struct fgraph_data *data)
248
{
249
	pid_t prev_pid;
250
	pid_t *last_pid;
251
	int ret;
252

253
	if (!data)
254 255
		return TRACE_TYPE_HANDLED;

256
	last_pid = &(per_cpu_ptr(data, cpu)->last_pid);
257 258

	if (*last_pid == pid)
259
		return TRACE_TYPE_HANDLED;
260

261 262
	prev_pid = *last_pid;
	*last_pid = pid;
263

264 265
	if (prev_pid == -1)
		return TRACE_TYPE_HANDLED;
266 267 268 269 270 271 272 273 274
/*
 * Context-switch trace line:

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

 */
	ret = trace_seq_printf(s,
275
		" ------------------------------------------\n");
276
	if (!ret)
277
		return TRACE_TYPE_PARTIAL_LINE;
278 279 280

	ret = print_graph_cpu(s, cpu);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
281
		return TRACE_TYPE_PARTIAL_LINE;
282 283 284

	ret = print_graph_proc(s, prev_pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
285
		return TRACE_TYPE_PARTIAL_LINE;
286 287 288

	ret = trace_seq_printf(s, " => ");
	if (!ret)
289
		return TRACE_TYPE_PARTIAL_LINE;
290 291 292

	ret = print_graph_proc(s, pid);
	if (ret == TRACE_TYPE_PARTIAL_LINE)
293
		return TRACE_TYPE_PARTIAL_LINE;
294 295 296 297

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

300
	return TRACE_TYPE_HANDLED;
301 302
}

303 304
static struct ftrace_graph_ret_entry *
get_return_for_leaf(struct trace_iterator *iter,
305 306 307 308 309 310 311 312
		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];

313 314 315 316 317 318 319 320 321
	/* 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);
	}
322 323

	if (!event)
324
		return NULL;
325 326 327 328

	next = ring_buffer_event_data(event);

	if (next->ent.type != TRACE_GRAPH_RET)
329
		return NULL;
330 331 332

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

335 336 337 338 339
	/* this is a leaf, now advance the iterator */
	if (ring_iter)
		ring_buffer_read(ring_iter, NULL);

	return next;
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
/* 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, "  ");
}

367 368 369 370 371 372 373 374 375 376 377
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);
}

378
static enum print_line_t
379
print_graph_irq(struct trace_iterator *iter, unsigned long addr,
380
		enum trace_type type, int cpu, pid_t pid)
381 382
{
	int ret;
383
	struct trace_seq *s = &iter->seq;
384 385 386 387 388

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

389 390 391 392 393 394 395
	/* 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;
	}

396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
	/* 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;
	}
411

412 413 414 415
	/* No overhead */
	ret = print_graph_overhead(-1, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
416

417 418 419 420 421 422 423 424 425 426 427 428
	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");
429 430 431 432 433

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

435 436
enum print_line_t
trace_print_graph_duration(unsigned long long duration, struct trace_seq *s)
437 438
{
	unsigned long nsecs_rem = do_div(duration, 1000);
439 440 441 442 443 444 445 446 447
	/* 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 */
448
	ret = trace_seq_printf(s, "%s", msecs_str);
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;
	}
473 474 475 476 477 478 479 480 481 482 483
	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
print_graph_duration(unsigned long long duration, struct trace_seq *s)
{
	int ret;

	ret = trace_print_graph_duration(duration, s);
	if (ret != TRACE_TYPE_HANDLED)
		return ret;
484 485 486 487 488

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

489
	return TRACE_TYPE_HANDLED;
490 491 492
}

/* Case of a leaf function on its call entry */
493
static enum print_line_t
494
print_graph_entry_leaf(struct trace_iterator *iter,
495 496
		struct ftrace_graph_ent_entry *entry,
		struct ftrace_graph_ret_entry *ret_entry, struct trace_seq *s)
497
{
498
	struct fgraph_data *data = iter->private;
499 500 501
	struct ftrace_graph_ret *graph_ret;
	struct ftrace_graph_ent *call;
	unsigned long long duration;
502
	int ret;
503
	int i;
504

505 506 507 508
	graph_ret = &ret_entry->ret;
	call = &entry->graph_ent;
	duration = graph_ret->rettime - graph_ret->calltime;

509 510 511 512 513 514 515 516 517 518 519 520
	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;
	}

521
	/* Overhead */
522 523 524
	ret = print_graph_overhead(duration, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
525 526

	/* Duration */
527 528 529 530 531
	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;
	}
532

533 534 535 536 537 538 539 540 541 542 543
	/* 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;

544
	ret = trace_seq_printf(s, "();\n");
545 546 547 548 549 550 551
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

static enum print_line_t
552 553 554
print_graph_entry_nested(struct trace_iterator *iter,
			 struct ftrace_graph_ent_entry *entry,
			 struct trace_seq *s, int cpu)
555 556
{
	struct ftrace_graph_ent *call = &entry->graph_ent;
557 558 559 560 561 562 563 564 565 566
	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;
	}
567 568

	/* No overhead */
569 570 571
	ret = print_graph_overhead(-1, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
572

573 574
	/* No time */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION) {
575 576 577 578 579
		ret = trace_seq_printf(s, "            |  ");
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

580
	/* Function */
581 582
	for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
583 584
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
585 586 587 588 589 590
	}

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

591
	ret = trace_seq_printf(s, "() {\n");
592 593 594
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

595 596 597 598 599
	/*
	 * we already consumed the current entry to check the next one
	 * and see if this is a leaf.
	 */
	return TRACE_TYPE_NO_CONSUME;
600 601
}

602
static enum print_line_t
603 604
print_graph_prologue(struct trace_iterator *iter, struct trace_seq *s,
		     int type, unsigned long addr)
605
{
606
	struct fgraph_data *data = iter->private;
607
	struct trace_entry *ent = iter->ent;
608 609
	int cpu = iter->cpu;
	int ret;
610

611
	/* Pid */
612
	if (verif_pid(s, ent->pid, cpu, data) == TRACE_TYPE_PARTIAL_LINE)
613 614
		return TRACE_TYPE_PARTIAL_LINE;

615 616 617 618 619 620
	if (type) {
		/* Interrupt */
		ret = print_graph_irq(iter, addr, type, cpu, ent->pid);
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}
621

622 623 624 625 626 627 628
	/* 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;
	}

629 630 631
	/* Cpu */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
		ret = print_graph_cpu(s, cpu);
632 633 634 635 636 637
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Proc */
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
638
		ret = print_graph_proc(s, ent->pid);
639 640 641 642
		if (ret == TRACE_TYPE_PARTIAL_LINE)
			return TRACE_TYPE_PARTIAL_LINE;

		ret = trace_seq_printf(s, " | ");
643 644 645
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}
646

647 648 649 650 651 652 653 654 655 656 657 658 659 660
	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;

661 662 663
	leaf_ret = get_return_for_leaf(iter, field);
	if (leaf_ret)
		return print_graph_entry_leaf(iter, field, leaf_ret, s);
664
	else
665
		return print_graph_entry_nested(iter, field, s, cpu);
666 667 668

}

669 670
static enum print_line_t
print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
671
		   struct trace_entry *ent, struct trace_iterator *iter)
672
{
673
	unsigned long long duration = trace->rettime - trace->calltime;
674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
	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;
	}
691

692
	if (print_graph_prologue(iter, s, 0, 0))
693 694
		return TRACE_TYPE_PARTIAL_LINE;

695
	/* Overhead */
696 697 698
	ret = print_graph_overhead(duration, s);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
699 700

	/* Duration */
701 702 703 704 705
	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;
	}
706 707

	/* Closing brace */
708 709
	for (i = 0; i < trace->depth * TRACE_GRAPH_INDENT; i++) {
		ret = trace_seq_printf(s, " ");
710 711
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
712 713
	}

714
	ret = trace_seq_printf(s, "}\n");
715 716
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;
717

718
	/* Overrun */
719 720 721
	if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERRUN) {
		ret = trace_seq_printf(s, " (Overruns: %lu)\n",
					trace->overrun);
722 723
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
724
	}
725

726
	ret = print_graph_irq(iter, trace->func, TRACE_GRAPH_RET, cpu, pid);
727 728 729
	if (ret == TRACE_TYPE_PARTIAL_LINE)
		return TRACE_TYPE_PARTIAL_LINE;

730 731 732
	return TRACE_TYPE_HANDLED;
}

733
static enum print_line_t
734 735
print_graph_comment(struct trace_seq *s,  struct trace_entry *ent,
		    struct trace_iterator *iter)
736
{
737
	unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK);
738
	struct fgraph_data *data = iter->private;
739
	struct trace_event *event;
740
	int depth = 0;
741
	int ret;
742 743 744 745
	int i;

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

747
	if (print_graph_prologue(iter, s, 0, 0))
748 749
		return TRACE_TYPE_PARTIAL_LINE;

750
	/* No overhead */
751 752 753 754 755 756 757
	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, "            |  ");
758 759 760 761 762
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

	/* Indentation */
763 764
	if (depth > 0)
		for (i = 0; i < (depth + 1) * TRACE_GRAPH_INDENT; i++) {
765 766 767 768 769 770
			ret = trace_seq_printf(s, " ");
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}

	/* The comment */
771 772 773 774
	ret = trace_seq_printf(s, "/* ");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
	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;
	}
795

796 797 798 799 800 801
	/* Strip ending newline */
	if (s->buffer[s->len - 1] == '\n') {
		s->buffer[s->len - 1] = '\0';
		s->len--;
	}

802 803 804 805 806 807 808 809
	ret = trace_seq_printf(s, " */\n");
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}


810 811 812 813
enum print_line_t
print_graph_function(struct trace_iterator *iter)
{
	struct trace_entry *entry = iter->ent;
814
	struct trace_seq *s = &iter->seq;
815

816 817 818 819
	switch (entry->type) {
	case TRACE_GRAPH_ENT: {
		struct ftrace_graph_ent_entry *field;
		trace_assign_type(field, entry);
820
		return print_graph_entry(field, s, iter);
821 822 823 824
	}
	case TRACE_GRAPH_RET: {
		struct ftrace_graph_ret_entry *field;
		trace_assign_type(field, entry);
825
		return print_graph_return(&field->ret, s, entry, iter);
826 827
	}
	default:
828
		return print_graph_comment(s, entry, iter);
829
	}
830 831

	return TRACE_TYPE_HANDLED;
832 833
}

834 835 836 837
static void print_graph_headers(struct seq_file *s)
{
	/* 1st line */
	seq_printf(s, "# ");
838 839
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
		seq_printf(s, "     TIME       ");
840
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
841
		seq_printf(s, "CPU");
842
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
843 844 845 846
		seq_printf(s, "  TASK/PID      ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
		seq_printf(s, "  DURATION   ");
	seq_printf(s, "               FUNCTION CALLS\n");
847 848 849

	/* 2nd line */
	seq_printf(s, "# ");
850 851
	if (tracer_flags.val & TRACE_GRAPH_PRINT_ABS_TIME)
		seq_printf(s, "      |         ");
852
	if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
853
		seq_printf(s, "|  ");
854
	if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
855 856 857 858
		seq_printf(s, "  |    |        ");
	if (tracer_flags.val & TRACE_GRAPH_PRINT_DURATION)
		seq_printf(s, "   |   |      ");
	seq_printf(s, "               |   |   |   |\n");
859
}
860 861 862

static void graph_trace_open(struct trace_iterator *iter)
{
863 864
	/* pid and depth on the last trace processed */
	struct fgraph_data *data = alloc_percpu(struct fgraph_data);
865 866
	int cpu;

867
	if (!data)
868 869 870
		pr_warning("function graph tracer: not enough memory\n");
	else
		for_each_possible_cpu(cpu) {
871 872
			pid_t *pid = &(per_cpu_ptr(data, cpu)->last_pid);
			int *depth = &(per_cpu_ptr(data, cpu)->depth);
873
			*pid = -1;
874
			*depth = 0;
875 876
		}

877
	iter->private = data;
878 879 880 881
}

static void graph_trace_close(struct trace_iterator *iter)
{
882
	free_percpu(iter->private);
883 884
}

885
static struct tracer graph_trace __read_mostly = {
886
	.name		= "function_graph",
887 888
	.open		= graph_trace_open,
	.close		= graph_trace_close,
889
	.wait_pipe	= poll_wait_pipe,
890 891
	.init		= graph_trace_init,
	.reset		= graph_trace_reset,
892 893
	.print_line	= print_graph_function,
	.print_header	= print_graph_headers,
894
	.flags		= &tracer_flags,
895 896 897
#ifdef CONFIG_FTRACE_SELFTEST
	.selftest	= trace_selftest_startup_function_graph,
#endif
898 899 900 901 902 903 904 905
};

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

device_initcall(init_graph_trace);