1 #ifndef _LINUX_KERNEL_TRACE_H 2 #define _LINUX_KERNEL_TRACE_H 3 4 #include <linux/fs.h> 5 #include <asm/atomic.h> 6 #include <linux/sched.h> 7 #include <linux/clocksource.h> 8 #include <linux/mmiotrace.h> 9 10 enum trace_type { 11 __TRACE_FIRST_TYPE = 0, 12 13 TRACE_FN, 14 TRACE_CTX, 15 TRACE_WAKE, 16 TRACE_STACK, 17 TRACE_SPECIAL, 18 TRACE_MMIO_RW, 19 TRACE_MMIO_MAP, 20 21 __TRACE_LAST_TYPE 22 }; 23 24 /* 25 * Function trace entry - function address and parent function addres: 26 */ 27 struct ftrace_entry { 28 unsigned long ip; 29 unsigned long parent_ip; 30 }; 31 32 /* 33 * Context switch trace entry - which task (and prio) we switched from/to: 34 */ 35 struct ctx_switch_entry { 36 unsigned int prev_pid; 37 unsigned char prev_prio; 38 unsigned char prev_state; 39 unsigned int next_pid; 40 unsigned char next_prio; 41 unsigned char next_state; 42 }; 43 44 /* 45 * Special (free-form) trace entry: 46 */ 47 struct special_entry { 48 unsigned long arg1; 49 unsigned long arg2; 50 unsigned long arg3; 51 }; 52 53 /* 54 * Stack-trace entry: 55 */ 56 57 #define FTRACE_STACK_ENTRIES 8 58 59 struct stack_entry { 60 unsigned long caller[FTRACE_STACK_ENTRIES]; 61 }; 62 63 /* 64 * The trace entry - the most basic unit of tracing. This is what 65 * is printed in the end as a single line in the trace output, such as: 66 * 67 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter 68 */ 69 struct trace_entry { 70 char type; 71 char cpu; 72 char flags; 73 char preempt_count; 74 int pid; 75 cycle_t t; 76 union { 77 struct ftrace_entry fn; 78 struct ctx_switch_entry ctx; 79 struct special_entry special; 80 struct stack_entry stack; 81 struct mmiotrace_rw mmiorw; 82 struct mmiotrace_map mmiomap; 83 }; 84 }; 85 86 #define TRACE_ENTRY_SIZE sizeof(struct trace_entry) 87 88 /* 89 * The CPU trace array - it consists of thousands of trace entries 90 * plus some other descriptor data: (for example which task started 91 * the trace, etc.) 92 */ 93 struct trace_array_cpu { 94 struct list_head trace_pages; 95 atomic_t disabled; 96 raw_spinlock_t lock; 97 struct lock_class_key lock_key; 98 99 /* these fields get copied into max-trace: */ 100 unsigned trace_head_idx; 101 unsigned trace_tail_idx; 102 void *trace_head; /* producer */ 103 void *trace_tail; /* consumer */ 104 unsigned long trace_idx; 105 unsigned long overrun; 106 unsigned long saved_latency; 107 unsigned long critical_start; 108 unsigned long critical_end; 109 unsigned long critical_sequence; 110 unsigned long nice; 111 unsigned long policy; 112 unsigned long rt_priority; 113 cycle_t preempt_timestamp; 114 pid_t pid; 115 uid_t uid; 116 char comm[TASK_COMM_LEN]; 117 }; 118 119 struct trace_iterator; 120 121 /* 122 * The trace array - an array of per-CPU trace arrays. This is the 123 * highest level data structure that individual tracers deal with. 124 * They have on/off state as well: 125 */ 126 struct trace_array { 127 unsigned long entries; 128 long ctrl; 129 int cpu; 130 cycle_t time_start; 131 struct task_struct *waiter; 132 struct trace_array_cpu *data[NR_CPUS]; 133 }; 134 135 /* 136 * A specific tracer, represented by methods that operate on a trace array: 137 */ 138 struct tracer { 139 const char *name; 140 void (*init)(struct trace_array *tr); 141 void (*reset)(struct trace_array *tr); 142 void (*open)(struct trace_iterator *iter); 143 void (*pipe_open)(struct trace_iterator *iter); 144 void (*close)(struct trace_iterator *iter); 145 void (*start)(struct trace_iterator *iter); 146 void (*stop)(struct trace_iterator *iter); 147 ssize_t (*read)(struct trace_iterator *iter, 148 struct file *filp, char __user *ubuf, 149 size_t cnt, loff_t *ppos); 150 void (*ctrl_update)(struct trace_array *tr); 151 #ifdef CONFIG_FTRACE_STARTUP_TEST 152 int (*selftest)(struct tracer *trace, 153 struct trace_array *tr); 154 #endif 155 int (*print_line)(struct trace_iterator *iter); 156 struct tracer *next; 157 int print_max; 158 }; 159 160 struct trace_seq { 161 unsigned char buffer[PAGE_SIZE]; 162 unsigned int len; 163 unsigned int readpos; 164 }; 165 166 /* 167 * Trace iterator - used by printout routines who present trace 168 * results to users and which routines might sleep, etc: 169 */ 170 struct trace_iterator { 171 struct trace_array *tr; 172 struct tracer *trace; 173 void *private; 174 long last_overrun[NR_CPUS]; 175 long overrun[NR_CPUS]; 176 177 /* The below is zeroed out in pipe_read */ 178 struct trace_seq seq; 179 struct trace_entry *ent; 180 int cpu; 181 182 struct trace_entry *prev_ent; 183 int prev_cpu; 184 185 unsigned long iter_flags; 186 loff_t pos; 187 unsigned long next_idx[NR_CPUS]; 188 struct list_head *next_page[NR_CPUS]; 189 unsigned next_page_idx[NR_CPUS]; 190 long idx; 191 }; 192 193 void tracing_reset(struct trace_array_cpu *data); 194 int tracing_open_generic(struct inode *inode, struct file *filp); 195 struct dentry *tracing_init_dentry(void); 196 void init_tracer_sysprof_debugfs(struct dentry *d_tracer); 197 198 void ftrace(struct trace_array *tr, 199 struct trace_array_cpu *data, 200 unsigned long ip, 201 unsigned long parent_ip, 202 unsigned long flags); 203 void tracing_sched_switch_trace(struct trace_array *tr, 204 struct trace_array_cpu *data, 205 struct task_struct *prev, 206 struct task_struct *next, 207 unsigned long flags); 208 void tracing_record_cmdline(struct task_struct *tsk); 209 210 void tracing_sched_wakeup_trace(struct trace_array *tr, 211 struct trace_array_cpu *data, 212 struct task_struct *wakee, 213 struct task_struct *cur, 214 unsigned long flags); 215 void trace_special(struct trace_array *tr, 216 struct trace_array_cpu *data, 217 unsigned long arg1, 218 unsigned long arg2, 219 unsigned long arg3); 220 void trace_function(struct trace_array *tr, 221 struct trace_array_cpu *data, 222 unsigned long ip, 223 unsigned long parent_ip, 224 unsigned long flags); 225 226 void tracing_start_cmdline_record(void); 227 void tracing_stop_cmdline_record(void); 228 int register_tracer(struct tracer *type); 229 void unregister_tracer(struct tracer *type); 230 231 extern unsigned long nsecs_to_usecs(unsigned long nsecs); 232 233 extern unsigned long tracing_max_latency; 234 extern unsigned long tracing_thresh; 235 236 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu); 237 void update_max_tr_single(struct trace_array *tr, 238 struct task_struct *tsk, int cpu); 239 240 extern cycle_t ftrace_now(int cpu); 241 242 #ifdef CONFIG_FTRACE 243 void tracing_start_function_trace(void); 244 void tracing_stop_function_trace(void); 245 #else 246 # define tracing_start_function_trace() do { } while (0) 247 # define tracing_stop_function_trace() do { } while (0) 248 #endif 249 250 #ifdef CONFIG_CONTEXT_SWITCH_TRACER 251 typedef void 252 (*tracer_switch_func_t)(void *private, 253 void *__rq, 254 struct task_struct *prev, 255 struct task_struct *next); 256 257 struct tracer_switch_ops { 258 tracer_switch_func_t func; 259 void *private; 260 struct tracer_switch_ops *next; 261 }; 262 263 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */ 264 265 #ifdef CONFIG_DYNAMIC_FTRACE 266 extern unsigned long ftrace_update_tot_cnt; 267 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func 268 extern int DYN_FTRACE_TEST_NAME(void); 269 #endif 270 271 #ifdef CONFIG_MMIOTRACE 272 extern void __trace_mmiotrace_rw(struct trace_array *tr, 273 struct trace_array_cpu *data, 274 struct mmiotrace_rw *rw); 275 extern void __trace_mmiotrace_map(struct trace_array *tr, 276 struct trace_array_cpu *data, 277 struct mmiotrace_map *map); 278 #endif 279 280 #ifdef CONFIG_FTRACE_STARTUP_TEST 281 #ifdef CONFIG_FTRACE 282 extern int trace_selftest_startup_function(struct tracer *trace, 283 struct trace_array *tr); 284 #endif 285 #ifdef CONFIG_IRQSOFF_TRACER 286 extern int trace_selftest_startup_irqsoff(struct tracer *trace, 287 struct trace_array *tr); 288 #endif 289 #ifdef CONFIG_PREEMPT_TRACER 290 extern int trace_selftest_startup_preemptoff(struct tracer *trace, 291 struct trace_array *tr); 292 #endif 293 #if defined(CONFIG_IRQSOFF_TRACER) && defined(CONFIG_PREEMPT_TRACER) 294 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace, 295 struct trace_array *tr); 296 #endif 297 #ifdef CONFIG_SCHED_TRACER 298 extern int trace_selftest_startup_wakeup(struct tracer *trace, 299 struct trace_array *tr); 300 #endif 301 #ifdef CONFIG_CONTEXT_SWITCH_TRACER 302 extern int trace_selftest_startup_sched_switch(struct tracer *trace, 303 struct trace_array *tr); 304 #endif 305 #ifdef CONFIG_SYSPROF_TRACER 306 extern int trace_selftest_startup_sysprof(struct tracer *trace, 307 struct trace_array *tr); 308 #endif 309 #endif /* CONFIG_FTRACE_STARTUP_TEST */ 310 311 extern void *head_page(struct trace_array_cpu *data); 312 extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...); 313 extern ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, 314 size_t cnt); 315 extern long ns2usecs(cycle_t nsec); 316 317 extern unsigned long trace_flags; 318 319 /* 320 * trace_iterator_flags is an enumeration that defines bit 321 * positions into trace_flags that controls the output. 322 * 323 * NOTE: These bits must match the trace_options array in 324 * trace.c. 325 */ 326 enum trace_iterator_flags { 327 TRACE_ITER_PRINT_PARENT = 0x01, 328 TRACE_ITER_SYM_OFFSET = 0x02, 329 TRACE_ITER_SYM_ADDR = 0x04, 330 TRACE_ITER_VERBOSE = 0x08, 331 TRACE_ITER_RAW = 0x10, 332 TRACE_ITER_HEX = 0x20, 333 TRACE_ITER_BIN = 0x40, 334 TRACE_ITER_BLOCK = 0x80, 335 TRACE_ITER_STACKTRACE = 0x100, 336 TRACE_ITER_SCHED_TREE = 0x200, 337 }; 338 339 #endif /* _LINUX_KERNEL_TRACE_H */ 340