t - The LITMUS^RT kernel.
aboutsummaryrefslogblamecommitdiffstats
path: root/kernel/trace/trace_functions_graph.c
blob: 4bf39fcae97afadc384b104e5d77be0120e375e3 (plain) (tree)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15














                                                              
                                 
 
                  
                                           

                                           
                                           
 
                                         





                                                                       

                                                               



                                           
                                                        
                                                                  


                          
                                     
                                                            


                                                   

                     


                                       
                                                        
                                                            




                                       



                                                     

                                      

 

















                                                                  












                                                                 






                                                       

                                               


                                  










































                                                           
 
                                                                

                                                  
 

                       
 
                                                        
                                          
 
                                 
                            
 








                                           
                                                                 























                                                                     
                   

 












                                                    
                                                       















                                                               










































                                                                         
 
                        


                                                                      







































                                                                 

















                                                                      
                        

                                                                          
 




                                                 
                
              
 






                                                                     







                                                            
                                           

                                               










                                                                
                                           







                                                              
                                                                





                                                          





                                                            











                                                                        

                      

                                                                

                                                       





                                                 
                                            


                                               



                                  





                                                                            
                 
                                                                   

                                               


                                                       










                                                        


                                                       



                                                              
                                                                               



                        
                                                                       
                                                    


                
                                                                       
 
                 
                                                                   

                                               
                 

                                                       










                                                        


                                                       
 
                      







                                                            
                                           


                                               

                                                                 

                                                       

         
                                         

                                               
 
                     


                                                               

                                                       
         




                                                                              


                                  
































































                                                                               




                                                 
 



                                                     
                                                        
                                                    



                                                     
                                                                            
         




                                                                  

                                            
         

 























                                                                     
                                                  




                                               








                                             
/*
 *
 * Function graph tracer.
 * Copyright (c) 2008 Frederic Weisbecker <fweisbec@gmail.com>
 * 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"

#define TRACE_GRAPH_INDENT	2

/* Flag options */
#define TRACE_GRAPH_PRINT_OVERRUN	0x1
#define TRACE_GRAPH_PRINT_CPU		0x2
#define TRACE_GRAPH_PRINT_OVERHEAD	0x4
#define TRACE_GRAPH_PRINT_PROC		0x8

static struct tracer_opt trace_opts[] = {
	/* Display overruns ? */
	{ 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) },
	/* Display proc name/pid */
	{ TRACER_OPT(funcgraph-proc, TRACE_GRAPH_PRINT_PROC) },
	{ } /* Empty entry */
};

static struct tracer_flags tracer_flags = {
	/* Don't display overruns and proc by default */
	.val = TRACE_GRAPH_PRINT_CPU | TRACE_GRAPH_PRINT_OVERHEAD,
	.opts = trace_opts
};

/* pid on the last trace processed */
static pid_t last_pid[NR_CPUS] = { [0 ... NR_CPUS-1] = -1 };

static int graph_trace_init(struct trace_array *tr)
{
	int cpu, ret;

	for_each_online_cpu(cpu)
		tracing_reset(tr, cpu);

	ret = register_ftrace_graph(&trace_graph_return,
					&trace_graph_entry);
	if (ret)
		return ret;
	tracing_start_cmdline_record();

	return 0;
}

static void graph_trace_reset(struct trace_array *tr)
{
	tracing_stop_cmdline_record();
	unregister_ftrace_graph();
}

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);
	int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));


	/*
	 * 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:
	 */
	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)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

#define TRACE_GRAPH_PROCINFO_LENGTH	14

static enum print_line_t
print_graph_proc(struct trace_seq *s, pid_t pid)
{
	int i;
	int ret;
	int len;
	char comm[8];
	int spaces = 0;
	/* sign + log10(MAX_INT) + '\0' */
	char pid_str[11];

	strncpy(comm, trace_find_cmdline(pid), 7);
	comm[7] = '\0';
	sprintf(pid_str, "%d", pid);