Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 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> |
Steven Rostedt | 3928a8a | 2008-09-29 23:02:41 -0400 | [diff] [blame] | 8 | #include <linux/ring_buffer.h> |
Pekka Paalanen | bd8ac68 | 2008-05-12 21:20:57 +0200 | [diff] [blame] | 9 | #include <linux/mmiotrace.h> |
Steven Rostedt | 4e5292e | 2009-09-12 19:26:21 -0400 | [diff] [blame] | 10 | #include <linux/tracepoint.h> |
Frédéric Weisbecker | d13744c | 2008-09-23 11:32:08 +0100 | [diff] [blame] | 11 | #include <linux/ftrace.h> |
Frederic Weisbecker | 3f5ec13 | 2008-11-11 23:21:31 +0100 | [diff] [blame] | 12 | #include <trace/boot.h> |
Zhaolei | 02af61b | 2009-04-10 14:26:18 +0800 | [diff] [blame] | 13 | #include <linux/kmemtrace.h> |
Frederic Weisbecker | 24f1e32c | 2009-09-09 19:22:48 +0200 | [diff] [blame] | 14 | #include <linux/hw_breakpoint.h> |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 15 | |
Steven Rostedt | 9504504 | 2009-04-11 12:59:57 -0400 | [diff] [blame] | 16 | #include <linux/trace_seq.h> |
Steven Rostedt | 97f2025 | 2009-04-13 11:20:49 -0400 | [diff] [blame] | 17 | #include <linux/ftrace_event.h> |
Steven Rostedt | 9504504 | 2009-04-11 12:59:57 -0400 | [diff] [blame] | 18 | |
Thomas Gleixner | 72829bc | 2008-05-23 21:37:28 +0200 | [diff] [blame] | 19 | enum trace_type { |
| 20 | __TRACE_FIRST_TYPE = 0, |
| 21 | |
| 22 | TRACE_FN, |
| 23 | TRACE_CTX, |
| 24 | TRACE_WAKE, |
| 25 | TRACE_STACK, |
Steven Rostedt | dd0e545 | 2008-08-01 12:26:41 -0400 | [diff] [blame] | 26 | TRACE_PRINT, |
Frederic Weisbecker | 48ead02 | 2009-03-12 18:24:49 +0100 | [diff] [blame] | 27 | TRACE_BPRINT, |
Thomas Gleixner | 72829bc | 2008-05-23 21:37:28 +0200 | [diff] [blame] | 28 | TRACE_SPECIAL, |
Pekka Paalanen | bd8ac68 | 2008-05-12 21:20:57 +0200 | [diff] [blame] | 29 | TRACE_MMIO_RW, |
| 30 | TRACE_MMIO_MAP, |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 31 | TRACE_BRANCH, |
Frederic Weisbecker | 7423907 | 2008-11-11 23:24:42 +0100 | [diff] [blame] | 32 | TRACE_BOOT_CALL, |
| 33 | TRACE_BOOT_RET, |
Frederic Weisbecker | 287b6e6 | 2008-11-26 00:57:25 +0100 | [diff] [blame] | 34 | TRACE_GRAPH_RET, |
| 35 | TRACE_GRAPH_ENT, |
Török Edwin | 02b6751 | 2008-11-22 13:28:47 +0200 | [diff] [blame] | 36 | TRACE_USER_STACK, |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 37 | TRACE_KMEM_ALLOC, |
| 38 | TRACE_KMEM_FREE, |
Arnaldo Carvalho de Melo | c71a896 | 2009-01-23 12:06:27 -0200 | [diff] [blame] | 39 | TRACE_BLK, |
K.Prasad | 0722db0 | 2009-06-01 23:46:40 +0530 | [diff] [blame] | 40 | TRACE_KSYM, |
Thomas Gleixner | 72829bc | 2008-05-23 21:37:28 +0200 | [diff] [blame] | 41 | |
Steven Rostedt | f0868d1 | 2008-12-23 23:24:12 -0500 | [diff] [blame] | 42 | __TRACE_LAST_TYPE, |
Thomas Gleixner | 72829bc | 2008-05-23 21:37:28 +0200 | [diff] [blame] | 43 | }; |
| 44 | |
Eduard - Gabriel Munteanu | ca2b84cb | 2009-03-23 15:12:24 +0200 | [diff] [blame] | 45 | enum kmemtrace_type_id { |
| 46 | KMEMTRACE_TYPE_KMALLOC = 0, /* kmalloc() or kfree(). */ |
| 47 | KMEMTRACE_TYPE_CACHE, /* kmem_cache_*(). */ |
| 48 | KMEMTRACE_TYPE_PAGES, /* __get_free_pages() and friends. */ |
| 49 | }; |
| 50 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 51 | extern struct tracer boot_tracer; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 52 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 53 | #undef __field |
| 54 | #define __field(type, item) type item; |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 55 | |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 56 | #undef __field_struct |
| 57 | #define __field_struct(type, item) __field(type, item) |
| 58 | |
| 59 | #undef __field_desc |
| 60 | #define __field_desc(type, container, item) |
| 61 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 62 | #undef __array |
| 63 | #define __array(type, item, size) type item[size]; |
| 64 | |
Steven Rostedt | d731509 | 2009-09-12 19:22:23 -0400 | [diff] [blame] | 65 | #undef __array_desc |
| 66 | #define __array_desc(type, container, item, size) |
| 67 | |
Steven Rostedt | 0a1c49d | 2009-09-12 19:17:15 -0400 | [diff] [blame] | 68 | #undef __dynamic_array |
| 69 | #define __dynamic_array(type, item) type item[]; |
| 70 | |
| 71 | #undef F_STRUCT |
| 72 | #define F_STRUCT(args...) args |
| 73 | |
| 74 | #undef FTRACE_ENTRY |
| 75 | #define FTRACE_ENTRY(name, struct_name, id, tstruct, print) \ |
| 76 | struct struct_name { \ |
| 77 | struct trace_entry ent; \ |
| 78 | tstruct \ |
| 79 | } |
| 80 | |
| 81 | #undef TP_ARGS |
| 82 | #define TP_ARGS(args...) args |
| 83 | |
| 84 | #undef FTRACE_ENTRY_DUP |
| 85 | #define FTRACE_ENTRY_DUP(name, name_struct, id, tstruct, printk) |
| 86 | |
| 87 | #include "trace_entries.h" |
| 88 | |
| 89 | /* |
| 90 | * syscalls are special, and need special handling, this is why |
| 91 | * they are not included in trace_entries.h |
| 92 | */ |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 93 | struct syscall_trace_enter { |
| 94 | struct trace_entry ent; |
| 95 | int nr; |
| 96 | unsigned long args[]; |
| 97 | }; |
| 98 | |
| 99 | struct syscall_trace_exit { |
| 100 | struct trace_entry ent; |
| 101 | int nr; |
Tom Zanussi | 99df5a6 | 2009-11-25 01:14:59 -0600 | [diff] [blame] | 102 | long ret; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 103 | }; |
| 104 | |
Masami Hiramatsu | 93ccae7 | 2010-04-12 13:17:08 -0400 | [diff] [blame] | 105 | struct kprobe_trace_entry_head { |
Masami Hiramatsu | 413d37d | 2009-08-13 16:35:11 -0400 | [diff] [blame] | 106 | struct trace_entry ent; |
| 107 | unsigned long ip; |
Masami Hiramatsu | 413d37d | 2009-08-13 16:35:11 -0400 | [diff] [blame] | 108 | }; |
| 109 | |
Masami Hiramatsu | 93ccae7 | 2010-04-12 13:17:08 -0400 | [diff] [blame] | 110 | struct kretprobe_trace_entry_head { |
Masami Hiramatsu | 413d37d | 2009-08-13 16:35:11 -0400 | [diff] [blame] | 111 | struct trace_entry ent; |
| 112 | unsigned long func; |
| 113 | unsigned long ret_ip; |
Masami Hiramatsu | 413d37d | 2009-08-13 16:35:11 -0400 | [diff] [blame] | 114 | }; |
| 115 | |
Steven Rostedt | dd0e545 | 2008-08-01 12:26:41 -0400 | [diff] [blame] | 116 | /* |
Pekka Paalanen | fc5e27a | 2008-09-16 22:02:27 +0300 | [diff] [blame] | 117 | * trace_flag_type is an enumeration that holds different |
| 118 | * states when a trace occurs. These are: |
Steven Rostedt | 9244489 | 2008-10-24 09:42:59 -0400 | [diff] [blame] | 119 | * IRQS_OFF - interrupts were disabled |
Ingo Molnar | 9de3682 | 2009-03-06 17:52:03 +0100 | [diff] [blame] | 120 | * IRQS_NOSUPPORT - arch does not support irqs_disabled_flags |
Li Zefan | bd9cfca | 2009-09-10 09:34:19 +0800 | [diff] [blame] | 121 | * NEED_RESCHED - reschedule is requested |
Steven Rostedt | 9244489 | 2008-10-24 09:42:59 -0400 | [diff] [blame] | 122 | * HARDIRQ - inside an interrupt handler |
| 123 | * SOFTIRQ - inside a softirq handler |
Pekka Paalanen | fc5e27a | 2008-09-16 22:02:27 +0300 | [diff] [blame] | 124 | */ |
| 125 | enum trace_flag_type { |
| 126 | TRACE_FLAG_IRQS_OFF = 0x01, |
Steven Rostedt | 9244489 | 2008-10-24 09:42:59 -0400 | [diff] [blame] | 127 | TRACE_FLAG_IRQS_NOSUPPORT = 0x02, |
| 128 | TRACE_FLAG_NEED_RESCHED = 0x04, |
| 129 | TRACE_FLAG_HARDIRQ = 0x08, |
| 130 | TRACE_FLAG_SOFTIRQ = 0x10, |
Pekka Paalanen | fc5e27a | 2008-09-16 22:02:27 +0300 | [diff] [blame] | 131 | }; |
| 132 | |
Pekka Paalanen | 5bf9a1e | 2008-09-16 22:06:42 +0300 | [diff] [blame] | 133 | #define TRACE_BUF_SIZE 1024 |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 134 | |
| 135 | /* |
| 136 | * The CPU trace array - it consists of thousands of trace entries |
| 137 | * plus some other descriptor data: (for example which task started |
| 138 | * the trace, etc.) |
| 139 | */ |
| 140 | struct trace_array_cpu { |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 141 | atomic_t disabled; |
Steven Rostedt | 2cadf91 | 2008-12-01 22:20:19 -0500 | [diff] [blame] | 142 | void *buffer_page; /* ring buffer spare */ |
Ingo Molnar | 4e3c333 | 2008-05-12 21:20:45 +0200 | [diff] [blame] | 143 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 144 | unsigned long saved_latency; |
| 145 | unsigned long critical_start; |
| 146 | unsigned long critical_end; |
| 147 | unsigned long critical_sequence; |
| 148 | unsigned long nice; |
| 149 | unsigned long policy; |
| 150 | unsigned long rt_priority; |
Steven Rostedt | 2f26ebd | 2009-09-01 11:06:29 -0400 | [diff] [blame] | 151 | unsigned long skipped_entries; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 152 | cycle_t preempt_timestamp; |
| 153 | pid_t pid; |
| 154 | uid_t uid; |
| 155 | char comm[TASK_COMM_LEN]; |
| 156 | }; |
| 157 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 158 | /* |
| 159 | * The trace array - an array of per-CPU trace arrays. This is the |
| 160 | * highest level data structure that individual tracers deal with. |
| 161 | * They have on/off state as well: |
| 162 | */ |
| 163 | struct trace_array { |
Steven Rostedt | 3928a8a | 2008-09-29 23:02:41 -0400 | [diff] [blame] | 164 | struct ring_buffer *buffer; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 165 | unsigned long entries; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 166 | int cpu; |
| 167 | cycle_t time_start; |
Steven Rostedt | b3806b4 | 2008-05-12 21:20:46 +0200 | [diff] [blame] | 168 | struct task_struct *waiter; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 169 | struct trace_array_cpu *data[NR_CPUS]; |
| 170 | }; |
| 171 | |
Steven Rostedt | 7104f30 | 2008-10-01 10:52:51 -0400 | [diff] [blame] | 172 | #define FTRACE_CMP_TYPE(var, type) \ |
| 173 | __builtin_types_compatible_p(typeof(var), type *) |
| 174 | |
| 175 | #undef IF_ASSIGN |
| 176 | #define IF_ASSIGN(var, entry, etype, id) \ |
| 177 | if (FTRACE_CMP_TYPE(var, etype)) { \ |
| 178 | var = (typeof(var))(entry); \ |
| 179 | WARN_ON(id && (entry)->type != id); \ |
| 180 | break; \ |
| 181 | } |
| 182 | |
| 183 | /* Will cause compile errors if type is not found. */ |
| 184 | extern void __ftrace_bad_type(void); |
| 185 | |
| 186 | /* |
| 187 | * The trace_assign_type is a verifier that the entry type is |
| 188 | * the same as the type being assigned. To add new types simply |
| 189 | * add a line with the following format: |
| 190 | * |
| 191 | * IF_ASSIGN(var, ent, type, id); |
| 192 | * |
| 193 | * Where "type" is the trace type that includes the trace_entry |
| 194 | * as the "ent" item. And "id" is the trace identifier that is |
| 195 | * used in the trace_type enum. |
| 196 | * |
| 197 | * If the type can have more than one id, then use zero. |
| 198 | */ |
| 199 | #define trace_assign_type(var, ent) \ |
| 200 | do { \ |
| 201 | IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \ |
| 202 | IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \ |
Steven Rostedt | 7104f30 | 2008-10-01 10:52:51 -0400 | [diff] [blame] | 203 | IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \ |
Török Edwin | 02b6751 | 2008-11-22 13:28:47 +0200 | [diff] [blame] | 204 | IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\ |
Steven Rostedt | 7104f30 | 2008-10-01 10:52:51 -0400 | [diff] [blame] | 205 | IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \ |
Frederic Weisbecker | 48ead02 | 2009-03-12 18:24:49 +0100 | [diff] [blame] | 206 | IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \ |
Steven Rostedt | 7104f30 | 2008-10-01 10:52:51 -0400 | [diff] [blame] | 207 | IF_ASSIGN(var, ent, struct special_entry, 0); \ |
| 208 | IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \ |
| 209 | TRACE_MMIO_RW); \ |
| 210 | IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \ |
| 211 | TRACE_MMIO_MAP); \ |
Frederic Weisbecker | 7423907 | 2008-11-11 23:24:42 +0100 | [diff] [blame] | 212 | IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\ |
| 213 | IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\ |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 214 | IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \ |
Frederic Weisbecker | 287b6e6 | 2008-11-26 00:57:25 +0100 | [diff] [blame] | 215 | IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \ |
| 216 | TRACE_GRAPH_ENT); \ |
| 217 | IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \ |
| 218 | TRACE_GRAPH_RET); \ |
Frederic Weisbecker | 36994e5 | 2008-12-29 13:42:23 -0800 | [diff] [blame] | 219 | IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry, \ |
| 220 | TRACE_KMEM_ALLOC); \ |
| 221 | IF_ASSIGN(var, ent, struct kmemtrace_free_entry, \ |
| 222 | TRACE_KMEM_FREE); \ |
Li Zefan | db59504 | 2009-07-07 13:52:36 +0800 | [diff] [blame] | 223 | IF_ASSIGN(var, ent, struct ksym_trace_entry, TRACE_KSYM);\ |
Steven Rostedt | 7104f30 | 2008-10-01 10:52:51 -0400 | [diff] [blame] | 224 | __ftrace_bad_type(); \ |
| 225 | } while (0) |
Frederic Weisbecker | 2c4f035 | 2008-09-29 20:18:34 +0200 | [diff] [blame] | 226 | |
Frederic Weisbecker | adf9f19 | 2008-11-17 19:23:42 +0100 | [diff] [blame] | 227 | /* |
| 228 | * An option specific to a tracer. This is a boolean value. |
| 229 | * The bit is the bit index that sets its value on the |
| 230 | * flags value in struct tracer_flags. |
| 231 | */ |
| 232 | struct tracer_opt { |
Ingo Molnar | 9de3682 | 2009-03-06 17:52:03 +0100 | [diff] [blame] | 233 | const char *name; /* Will appear on the trace_options file */ |
| 234 | u32 bit; /* Mask assigned in val field in tracer_flags */ |
Frederic Weisbecker | adf9f19 | 2008-11-17 19:23:42 +0100 | [diff] [blame] | 235 | }; |
| 236 | |
| 237 | /* |
| 238 | * The set of specific options for a tracer. Your tracer |
| 239 | * have to set the initial value of the flags val. |
| 240 | */ |
| 241 | struct tracer_flags { |
| 242 | u32 val; |
Ingo Molnar | 9de3682 | 2009-03-06 17:52:03 +0100 | [diff] [blame] | 243 | struct tracer_opt *opts; |
Frederic Weisbecker | adf9f19 | 2008-11-17 19:23:42 +0100 | [diff] [blame] | 244 | }; |
| 245 | |
| 246 | /* Makes more easy to define a tracer opt */ |
| 247 | #define TRACER_OPT(s, b) .name = #s, .bit = b |
| 248 | |
Frederic Weisbecker | 034939b | 2009-01-08 10:03:56 -0800 | [diff] [blame] | 249 | |
Frederic Weisbecker | 6eaaa5d | 2009-02-11 02:25:00 +0100 | [diff] [blame] | 250 | /** |
| 251 | * struct tracer - a specific tracer and its callbacks to interact with debugfs |
| 252 | * @name: the name chosen to select it on the available_tracers file |
| 253 | * @init: called when one switches to this tracer (echo name > current_tracer) |
| 254 | * @reset: called when one switches to another tracer |
| 255 | * @start: called when tracing is unpaused (echo 1 > tracing_enabled) |
| 256 | * @stop: called when tracing is paused (echo 0 > tracing_enabled) |
| 257 | * @open: called when the trace file is opened |
| 258 | * @pipe_open: called when the trace_pipe file is opened |
| 259 | * @wait_pipe: override how the user waits for traces on trace_pipe |
| 260 | * @close: called when the trace file is released |
Steven Rostedt | c521efd | 2009-12-07 09:06:24 -0500 | [diff] [blame] | 261 | * @pipe_close: called when the trace_pipe file is released |
Frederic Weisbecker | 6eaaa5d | 2009-02-11 02:25:00 +0100 | [diff] [blame] | 262 | * @read: override the default read callback on trace_pipe |
| 263 | * @splice_read: override the default splice_read callback on trace_pipe |
| 264 | * @selftest: selftest to run on boot (see trace_selftest.c) |
| 265 | * @print_headers: override the first lines that describe your columns |
| 266 | * @print_line: callback that prints a trace |
| 267 | * @set_flag: signals one of your private flags changed (trace_options file) |
| 268 | * @flags: your private flags |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 269 | */ |
| 270 | struct tracer { |
| 271 | const char *name; |
Frederic Weisbecker | 1c80025 | 2008-11-16 05:57:26 +0100 | [diff] [blame] | 272 | int (*init)(struct trace_array *tr); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 273 | void (*reset)(struct trace_array *tr); |
Steven Rostedt | 9036990 | 2008-11-05 16:05:44 -0500 | [diff] [blame] | 274 | void (*start)(struct trace_array *tr); |
| 275 | void (*stop)(struct trace_array *tr); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 276 | void (*open)(struct trace_iterator *iter); |
Steven Rostedt | 107bad8 | 2008-05-12 21:21:01 +0200 | [diff] [blame] | 277 | void (*pipe_open)(struct trace_iterator *iter); |
Frederic Weisbecker | 6eaaa5d | 2009-02-11 02:25:00 +0100 | [diff] [blame] | 278 | void (*wait_pipe)(struct trace_iterator *iter); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 279 | void (*close)(struct trace_iterator *iter); |
Steven Rostedt | c521efd | 2009-12-07 09:06:24 -0500 | [diff] [blame] | 280 | void (*pipe_close)(struct trace_iterator *iter); |
Steven Rostedt | 107bad8 | 2008-05-12 21:21:01 +0200 | [diff] [blame] | 281 | ssize_t (*read)(struct trace_iterator *iter, |
| 282 | struct file *filp, char __user *ubuf, |
| 283 | size_t cnt, loff_t *ppos); |
Eduard - Gabriel Munteanu | 3c56819 | 2009-02-09 08:15:56 +0200 | [diff] [blame] | 284 | ssize_t (*splice_read)(struct trace_iterator *iter, |
| 285 | struct file *filp, |
| 286 | loff_t *ppos, |
| 287 | struct pipe_inode_info *pipe, |
| 288 | size_t len, |
| 289 | unsigned int flags); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 290 | #ifdef CONFIG_FTRACE_STARTUP_TEST |
| 291 | int (*selftest)(struct tracer *trace, |
| 292 | struct trace_array *tr); |
| 293 | #endif |
Markus Metzger | 8bba1bf | 2008-11-25 09:12:31 +0100 | [diff] [blame] | 294 | void (*print_header)(struct seq_file *m); |
Frederic Weisbecker | 2c4f035 | 2008-09-29 20:18:34 +0200 | [diff] [blame] | 295 | enum print_line_t (*print_line)(struct trace_iterator *iter); |
Frederic Weisbecker | adf9f19 | 2008-11-17 19:23:42 +0100 | [diff] [blame] | 296 | /* If you handled the flag setting, return 0 */ |
| 297 | int (*set_flag)(u32 old_flags, u32 bit, int set); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 298 | struct tracer *next; |
| 299 | int print_max; |
Ingo Molnar | 9de3682 | 2009-03-06 17:52:03 +0100 | [diff] [blame] | 300 | struct tracer_flags *flags; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 301 | }; |
| 302 | |
Steven Rostedt | f952075 | 2009-03-02 14:04:40 -0500 | [diff] [blame] | 303 | |
Frederic Weisbecker | b04cc6b | 2009-02-25 03:22:28 +0100 | [diff] [blame] | 304 | #define TRACE_PIPE_ALL_CPU -1 |
| 305 | |
Arnaldo Carvalho de Melo | b6f11df | 2009-02-05 18:02:00 -0200 | [diff] [blame] | 306 | int tracer_init(struct tracer *t, struct trace_array *tr); |
Steven Rostedt | 9036990 | 2008-11-05 16:05:44 -0500 | [diff] [blame] | 307 | int tracing_is_enabled(void); |
Pekka Paalanen | 45dcd8b | 2008-09-16 21:56:41 +0300 | [diff] [blame] | 308 | void trace_wake_up(void); |
Steven Rostedt | 3928a8a | 2008-09-29 23:02:41 -0400 | [diff] [blame] | 309 | void tracing_reset(struct trace_array *tr, int cpu); |
Pekka J Enberg | 213cc06 | 2008-12-19 12:08:39 +0200 | [diff] [blame] | 310 | void tracing_reset_online_cpus(struct trace_array *tr); |
Steven Rostedt | 9456f0f | 2009-05-06 21:54:09 -0400 | [diff] [blame] | 311 | void tracing_reset_current(int cpu); |
| 312 | void tracing_reset_current_online_cpus(void); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 313 | int tracing_open_generic(struct inode *inode, struct file *filp); |
Frederic Weisbecker | 5452af6 | 2009-03-27 00:25:38 +0100 | [diff] [blame] | 314 | struct dentry *trace_create_file(const char *name, |
| 315 | mode_t mode, |
| 316 | struct dentry *parent, |
| 317 | void *data, |
| 318 | const struct file_operations *fops); |
| 319 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 320 | struct dentry *tracing_init_dentry(void); |
Ingo Molnar | d618b3e | 2008-05-12 21:20:49 +0200 | [diff] [blame] | 321 | void init_tracer_sysprof_debugfs(struct dentry *d_tracer); |
| 322 | |
Arnaldo Carvalho de Melo | 51a763d | 2009-02-05 16:14:13 -0200 | [diff] [blame] | 323 | struct ring_buffer_event; |
| 324 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 325 | struct ring_buffer_event * |
| 326 | trace_buffer_lock_reserve(struct ring_buffer *buffer, |
| 327 | int type, |
| 328 | unsigned long len, |
| 329 | unsigned long flags, |
| 330 | int pc); |
| 331 | void trace_buffer_unlock_commit(struct ring_buffer *buffer, |
Arnaldo Carvalho de Melo | 51a763d | 2009-02-05 16:14:13 -0200 | [diff] [blame] | 332 | struct ring_buffer_event *event, |
| 333 | unsigned long flags, int pc); |
| 334 | |
Pekka Paalanen | 45dcd8b | 2008-09-16 21:56:41 +0300 | [diff] [blame] | 335 | struct trace_entry *tracing_get_trace_entry(struct trace_array *tr, |
| 336 | struct trace_array_cpu *data); |
Frederic Weisbecker | c4a8e8b | 2009-02-02 20:29:21 -0200 | [diff] [blame] | 337 | |
| 338 | struct trace_entry *trace_find_next_entry(struct trace_iterator *iter, |
| 339 | int *ent_cpu, u64 *ent_ts); |
| 340 | |
Frederic Weisbecker | 6eaaa5d | 2009-02-11 02:25:00 +0100 | [diff] [blame] | 341 | void default_wait_pipe(struct trace_iterator *iter); |
| 342 | void poll_wait_pipe(struct trace_iterator *iter); |
| 343 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 344 | void ftrace(struct trace_array *tr, |
| 345 | struct trace_array_cpu *data, |
| 346 | unsigned long ip, |
| 347 | unsigned long parent_ip, |
Steven Rostedt | 3869705 | 2008-10-01 13:14:09 -0400 | [diff] [blame] | 348 | unsigned long flags, int pc); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 349 | void tracing_sched_switch_trace(struct trace_array *tr, |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 350 | struct task_struct *prev, |
| 351 | struct task_struct *next, |
Steven Rostedt | 3869705 | 2008-10-01 13:14:09 -0400 | [diff] [blame] | 352 | unsigned long flags, int pc); |
Ingo Molnar | 5742279 | 2008-05-12 21:20:51 +0200 | [diff] [blame] | 353 | |
| 354 | void tracing_sched_wakeup_trace(struct trace_array *tr, |
Ingo Molnar | 5742279 | 2008-05-12 21:20:51 +0200 | [diff] [blame] | 355 | struct task_struct *wakee, |
| 356 | struct task_struct *cur, |
Steven Rostedt | 3869705 | 2008-10-01 13:14:09 -0400 | [diff] [blame] | 357 | unsigned long flags, int pc); |
Ingo Molnar | f0a920d | 2008-05-12 21:20:47 +0200 | [diff] [blame] | 358 | void trace_special(struct trace_array *tr, |
| 359 | struct trace_array_cpu *data, |
| 360 | unsigned long arg1, |
| 361 | unsigned long arg2, |
Steven Rostedt | 3869705 | 2008-10-01 13:14:09 -0400 | [diff] [blame] | 362 | unsigned long arg3, int pc); |
Steven Rostedt | 6fb44b7 | 2008-05-12 21:20:49 +0200 | [diff] [blame] | 363 | void trace_function(struct trace_array *tr, |
Steven Rostedt | 6fb44b7 | 2008-05-12 21:20:49 +0200 | [diff] [blame] | 364 | unsigned long ip, |
| 365 | unsigned long parent_ip, |
Steven Rostedt | 3869705 | 2008-10-01 13:14:09 -0400 | [diff] [blame] | 366 | unsigned long flags, int pc); |
Jiri Olsa | 62b915f | 2010-04-02 19:01:22 +0200 | [diff] [blame] | 367 | void trace_default_header(struct seq_file *m); |
| 368 | void print_trace_header(struct seq_file *m, struct trace_iterator *iter); |
| 369 | int trace_empty(struct trace_iterator *iter); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 370 | |
Frederic Weisbecker | 287b6e6 | 2008-11-26 00:57:25 +0100 | [diff] [blame] | 371 | void trace_graph_return(struct ftrace_graph_ret *trace); |
Steven Rostedt | e49dc19 | 2008-12-02 23:50:05 -0500 | [diff] [blame] | 372 | int trace_graph_entry(struct ftrace_graph_ent *trace); |
Frederic Weisbecker | 1a0799a | 2009-07-29 18:59:58 +0200 | [diff] [blame] | 373 | void set_graph_array(struct trace_array *tr); |
Markus Metzger | 1e9b51c | 2008-11-25 09:24:15 +0100 | [diff] [blame] | 374 | |
Steven Rostedt | 41bc814 | 2008-05-22 11:49:22 -0400 | [diff] [blame] | 375 | void tracing_start_cmdline_record(void); |
| 376 | void tracing_stop_cmdline_record(void); |
Steven Rostedt | e168e05 | 2008-11-07 22:36:02 -0500 | [diff] [blame] | 377 | void tracing_sched_switch_assign_trace(struct trace_array *tr); |
| 378 | void tracing_stop_sched_switch_record(void); |
| 379 | void tracing_start_sched_switch_record(void); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 380 | int register_tracer(struct tracer *type); |
| 381 | void unregister_tracer(struct tracer *type); |
Carsten Emde | b5130b1 | 2009-09-13 01:43:07 +0200 | [diff] [blame] | 382 | int is_tracing_stopped(void); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 383 | |
Frederic Weisbecker | 0f8f86c | 2009-10-18 01:09:09 +0200 | [diff] [blame] | 384 | extern int process_new_ksym_entry(char *ksymname, int op, unsigned long addr); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 385 | |
| 386 | extern unsigned long nsecs_to_usecs(unsigned long nsecs); |
| 387 | |
Tim Bird | 0e95017 | 2010-02-25 15:36:43 -0800 | [diff] [blame] | 388 | extern unsigned long tracing_thresh; |
| 389 | |
Steven Rostedt | 5d4a9db | 2009-08-27 16:52:21 -0400 | [diff] [blame] | 390 | #ifdef CONFIG_TRACER_MAX_TRACE |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 391 | extern unsigned long tracing_max_latency; |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 392 | |
| 393 | void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu); |
| 394 | void update_max_tr_single(struct trace_array *tr, |
| 395 | struct task_struct *tsk, int cpu); |
Steven Rostedt | 5d4a9db | 2009-08-27 16:52:21 -0400 | [diff] [blame] | 396 | #endif /* CONFIG_TRACER_MAX_TRACE */ |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 397 | |
Frederic Weisbecker | c0a0d0d | 2009-07-29 17:51:13 +0200 | [diff] [blame] | 398 | #ifdef CONFIG_STACKTRACE |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 399 | void ftrace_trace_stack(struct ring_buffer *buffer, unsigned long flags, |
Frederic Weisbecker | c0a0d0d | 2009-07-29 17:51:13 +0200 | [diff] [blame] | 400 | int skip, int pc); |
| 401 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 402 | void ftrace_trace_userstack(struct ring_buffer *buffer, unsigned long flags, |
Frederic Weisbecker | c0a0d0d | 2009-07-29 17:51:13 +0200 | [diff] [blame] | 403 | int pc); |
| 404 | |
| 405 | void __trace_stack(struct trace_array *tr, unsigned long flags, int skip, |
| 406 | int pc); |
| 407 | #else |
| 408 | static inline void ftrace_trace_stack(struct trace_array *tr, |
| 409 | unsigned long flags, int skip, int pc) |
| 410 | { |
| 411 | } |
| 412 | |
| 413 | static inline void ftrace_trace_userstack(struct trace_array *tr, |
| 414 | unsigned long flags, int pc) |
| 415 | { |
| 416 | } |
| 417 | |
| 418 | static inline void __trace_stack(struct trace_array *tr, unsigned long flags, |
| 419 | int skip, int pc) |
| 420 | { |
| 421 | } |
| 422 | #endif /* CONFIG_STACKTRACE */ |
Steven Rostedt | 5361499 | 2009-01-15 19:12:40 -0500 | [diff] [blame] | 423 | |
Ingo Molnar | e309b41 | 2008-05-12 21:20:51 +0200 | [diff] [blame] | 424 | extern cycle_t ftrace_now(int cpu); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 425 | |
Steven Rostedt | 4ca53085 | 2009-03-16 19:20:15 -0400 | [diff] [blame] | 426 | extern void trace_find_cmdline(int pid, char comm[]); |
Ingo Molnar | f7d48cb | 2008-12-29 13:02:17 +0100 | [diff] [blame] | 427 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 428 | #ifdef CONFIG_DYNAMIC_FTRACE |
| 429 | extern unsigned long ftrace_update_tot_cnt; |
Steven Rostedt | d05cdb2 | 2008-05-12 21:20:54 +0200 | [diff] [blame] | 430 | #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func |
| 431 | extern int DYN_FTRACE_TEST_NAME(void); |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 432 | #endif |
| 433 | |
Li Zefan | 020e5f8 | 2009-07-01 10:47:05 +0800 | [diff] [blame] | 434 | extern int ring_buffer_expanded; |
| 435 | extern bool tracing_selftest_disabled; |
Christoph Lameter | 9288f99 | 2009-10-07 19:17:45 -0400 | [diff] [blame] | 436 | DECLARE_PER_CPU(int, ftrace_cpu_disabled); |
Li Zefan | 020e5f8 | 2009-07-01 10:47:05 +0800 | [diff] [blame] | 437 | |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 438 | #ifdef CONFIG_FTRACE_STARTUP_TEST |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 439 | extern int trace_selftest_startup_function(struct tracer *trace, |
| 440 | struct trace_array *tr); |
Frederic Weisbecker | 7447dce | 2009-02-07 21:33:57 +0100 | [diff] [blame] | 441 | extern int trace_selftest_startup_function_graph(struct tracer *trace, |
| 442 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 443 | extern int trace_selftest_startup_irqsoff(struct tracer *trace, |
| 444 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 445 | extern int trace_selftest_startup_preemptoff(struct tracer *trace, |
| 446 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 447 | extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace, |
| 448 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 449 | extern int trace_selftest_startup_wakeup(struct tracer *trace, |
| 450 | struct trace_array *tr); |
Steven Noonan | fb1b6d8 | 2008-09-19 03:06:43 -0700 | [diff] [blame] | 451 | extern int trace_selftest_startup_nop(struct tracer *trace, |
| 452 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 453 | extern int trace_selftest_startup_sched_switch(struct tracer *trace, |
| 454 | struct trace_array *tr); |
Ingo Molnar | a6dd24f | 2008-05-12 21:20:47 +0200 | [diff] [blame] | 455 | extern int trace_selftest_startup_sysprof(struct tracer *trace, |
| 456 | struct trace_array *tr); |
Steven Rostedt | 80e5ea4 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 457 | extern int trace_selftest_startup_branch(struct tracer *trace, |
| 458 | struct trace_array *tr); |
K.Prasad | 0722db0 | 2009-06-01 23:46:40 +0530 | [diff] [blame] | 459 | extern int trace_selftest_startup_ksym(struct tracer *trace, |
| 460 | struct trace_array *tr); |
Steven Rostedt | 60a1177 | 2008-05-12 21:20:44 +0200 | [diff] [blame] | 461 | #endif /* CONFIG_FTRACE_STARTUP_TEST */ |
| 462 | |
Ingo Molnar | c7aafc5 | 2008-05-12 21:20:45 +0200 | [diff] [blame] | 463 | extern void *head_page(struct trace_array_cpu *data); |
Lai Jiangshan | cf8e347 | 2009-03-30 13:48:00 +0800 | [diff] [blame] | 464 | extern unsigned long long ns2usecs(cycle_t nsec); |
Frederic Weisbecker | 1fd8f2a | 2008-12-03 23:45:11 +0100 | [diff] [blame] | 465 | extern int |
Steven Rostedt | 40ce74f | 2009-03-19 14:03:53 -0400 | [diff] [blame] | 466 | trace_vbprintk(unsigned long ip, const char *fmt, va_list args); |
Frederic Weisbecker | 48ead02 | 2009-03-12 18:24:49 +0100 | [diff] [blame] | 467 | extern int |
Steven Rostedt | 40ce74f | 2009-03-19 14:03:53 -0400 | [diff] [blame] | 468 | trace_vprintk(unsigned long ip, const char *fmt, va_list args); |
Steven Rostedt | 659372d | 2009-09-03 19:11:07 -0400 | [diff] [blame] | 469 | extern int |
| 470 | trace_array_vprintk(struct trace_array *tr, |
| 471 | unsigned long ip, const char *fmt, va_list args); |
| 472 | int trace_array_printk(struct trace_array *tr, |
| 473 | unsigned long ip, const char *fmt, ...); |
Ingo Molnar | c7aafc5 | 2008-05-12 21:20:45 +0200 | [diff] [blame] | 474 | |
Ingo Molnar | 4e65551 | 2008-05-12 21:20:52 +0200 | [diff] [blame] | 475 | extern unsigned long trace_flags; |
| 476 | |
Zhaolei | 5079f32 | 2009-08-25 16:12:56 +0800 | [diff] [blame] | 477 | extern int trace_clock_id; |
| 478 | |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 479 | /* Standard output formatting function used for function return traces */ |
Frederic Weisbecker | fb52607 | 2008-11-25 21:07:04 +0100 | [diff] [blame] | 480 | #ifdef CONFIG_FUNCTION_GRAPH_TRACER |
Jiri Olsa | 62b915f | 2010-04-02 19:01:22 +0200 | [diff] [blame] | 481 | |
| 482 | /* Flag options */ |
| 483 | #define TRACE_GRAPH_PRINT_OVERRUN 0x1 |
| 484 | #define TRACE_GRAPH_PRINT_CPU 0x2 |
| 485 | #define TRACE_GRAPH_PRINT_OVERHEAD 0x4 |
| 486 | #define TRACE_GRAPH_PRINT_PROC 0x8 |
| 487 | #define TRACE_GRAPH_PRINT_DURATION 0x10 |
| 488 | #define TRACE_GRAPH_PRINT_ABS_TIME 0x20 |
| 489 | |
Jiri Olsa | d7a8d9e | 2010-04-02 19:01:21 +0200 | [diff] [blame] | 490 | extern enum print_line_t |
| 491 | print_graph_function_flags(struct trace_iterator *iter, u32 flags); |
| 492 | extern void print_graph_headers_flags(struct seq_file *s, u32 flags); |
Steven Rostedt | 0706f1c | 2009-03-23 23:12:58 -0400 | [diff] [blame] | 493 | extern enum print_line_t |
| 494 | trace_print_graph_duration(unsigned long long duration, struct trace_seq *s); |
Jiri Olsa | 62b915f | 2010-04-02 19:01:22 +0200 | [diff] [blame] | 495 | extern void graph_trace_open(struct trace_iterator *iter); |
| 496 | extern void graph_trace_close(struct trace_iterator *iter); |
| 497 | extern int __trace_graph_entry(struct trace_array *tr, |
| 498 | struct ftrace_graph_ent *trace, |
| 499 | unsigned long flags, int pc); |
| 500 | extern void __trace_graph_return(struct trace_array *tr, |
| 501 | struct ftrace_graph_ret *trace, |
| 502 | unsigned long flags, int pc); |
| 503 | |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 504 | |
| 505 | #ifdef CONFIG_DYNAMIC_FTRACE |
| 506 | /* TODO: make this variable */ |
| 507 | #define FTRACE_GRAPH_MAX_FUNCS 32 |
Li Zefan | c7c6b1f | 2010-02-10 15:43:04 +0800 | [diff] [blame] | 508 | extern int ftrace_graph_filter_enabled; |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 509 | extern int ftrace_graph_count; |
| 510 | extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS]; |
| 511 | |
| 512 | static inline int ftrace_graph_addr(unsigned long addr) |
| 513 | { |
| 514 | int i; |
| 515 | |
Li Zefan | c7c6b1f | 2010-02-10 15:43:04 +0800 | [diff] [blame] | 516 | if (!ftrace_graph_filter_enabled) |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 517 | return 1; |
| 518 | |
| 519 | for (i = 0; i < ftrace_graph_count; i++) { |
| 520 | if (addr == ftrace_graph_funcs[i]) |
| 521 | return 1; |
| 522 | } |
| 523 | |
| 524 | return 0; |
| 525 | } |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 526 | #else |
Ingo Molnar | 6b25393 | 2008-12-04 09:18:28 +0100 | [diff] [blame] | 527 | static inline int ftrace_graph_addr(unsigned long addr) |
| 528 | { |
| 529 | return 1; |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 530 | } |
| 531 | #endif /* CONFIG_DYNAMIC_FTRACE */ |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 532 | #else /* CONFIG_FUNCTION_GRAPH_TRACER */ |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 533 | static inline enum print_line_t |
Jiri Olsa | d7a8d9e | 2010-04-02 19:01:21 +0200 | [diff] [blame] | 534 | print_graph_function_flags(struct trace_iterator *iter, u32 flags) |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 535 | { |
| 536 | return TRACE_TYPE_UNHANDLED; |
| 537 | } |
Steven Rostedt | ea4e2bc | 2008-12-03 15:36:57 -0500 | [diff] [blame] | 538 | #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 539 | |
jolsa@redhat.com | 756d17e | 2009-10-13 16:33:52 -0400 | [diff] [blame] | 540 | extern struct list_head ftrace_pids; |
Steven Rostedt | 804a685 | 2008-12-03 15:36:59 -0500 | [diff] [blame] | 541 | |
Paul Mundt | 1155de4 | 2009-06-25 14:30:12 +0900 | [diff] [blame] | 542 | #ifdef CONFIG_FUNCTION_TRACER |
Steven Rostedt | 804a685 | 2008-12-03 15:36:59 -0500 | [diff] [blame] | 543 | static inline int ftrace_trace_task(struct task_struct *task) |
| 544 | { |
jolsa@redhat.com | 756d17e | 2009-10-13 16:33:52 -0400 | [diff] [blame] | 545 | if (list_empty(&ftrace_pids)) |
Steven Rostedt | 804a685 | 2008-12-03 15:36:59 -0500 | [diff] [blame] | 546 | return 1; |
| 547 | |
| 548 | return test_tsk_trace_trace(task); |
| 549 | } |
Paul Mundt | 1155de4 | 2009-06-25 14:30:12 +0900 | [diff] [blame] | 550 | #else |
| 551 | static inline int ftrace_trace_task(struct task_struct *task) |
| 552 | { |
| 553 | return 1; |
| 554 | } |
| 555 | #endif |
Steven Rostedt | 804a685 | 2008-12-03 15:36:59 -0500 | [diff] [blame] | 556 | |
Steven Rostedt | 4fcdae8 | 2008-05-12 21:21:00 +0200 | [diff] [blame] | 557 | /* |
jolsa@redhat.com | b63f39e | 2009-09-11 17:29:27 +0200 | [diff] [blame] | 558 | * struct trace_parser - servers for reading the user input separated by spaces |
| 559 | * @cont: set if the input is not complete - no final space char was found |
| 560 | * @buffer: holds the parsed user input |
Daniel Mack | 1537a36 | 2010-01-29 15:57:49 +0800 | [diff] [blame] | 561 | * @idx: user input length |
jolsa@redhat.com | b63f39e | 2009-09-11 17:29:27 +0200 | [diff] [blame] | 562 | * @size: buffer size |
| 563 | */ |
| 564 | struct trace_parser { |
| 565 | bool cont; |
| 566 | char *buffer; |
| 567 | unsigned idx; |
| 568 | unsigned size; |
| 569 | }; |
| 570 | |
| 571 | static inline bool trace_parser_loaded(struct trace_parser *parser) |
| 572 | { |
| 573 | return (parser->idx != 0); |
| 574 | } |
| 575 | |
| 576 | static inline bool trace_parser_cont(struct trace_parser *parser) |
| 577 | { |
| 578 | return parser->cont; |
| 579 | } |
| 580 | |
| 581 | static inline void trace_parser_clear(struct trace_parser *parser) |
| 582 | { |
| 583 | parser->cont = false; |
| 584 | parser->idx = 0; |
| 585 | } |
| 586 | |
| 587 | extern int trace_parser_get_init(struct trace_parser *parser, int size); |
| 588 | extern void trace_parser_put(struct trace_parser *parser); |
| 589 | extern int trace_get_user(struct trace_parser *parser, const char __user *ubuf, |
| 590 | size_t cnt, loff_t *ppos); |
| 591 | |
| 592 | /* |
Steven Rostedt | 4fcdae8 | 2008-05-12 21:21:00 +0200 | [diff] [blame] | 593 | * trace_iterator_flags is an enumeration that defines bit |
| 594 | * positions into trace_flags that controls the output. |
| 595 | * |
| 596 | * NOTE: These bits must match the trace_options array in |
| 597 | * trace.c. |
| 598 | */ |
Ingo Molnar | 4e65551 | 2008-05-12 21:20:52 +0200 | [diff] [blame] | 599 | enum trace_iterator_flags { |
| 600 | TRACE_ITER_PRINT_PARENT = 0x01, |
| 601 | TRACE_ITER_SYM_OFFSET = 0x02, |
| 602 | TRACE_ITER_SYM_ADDR = 0x04, |
| 603 | TRACE_ITER_VERBOSE = 0x08, |
| 604 | TRACE_ITER_RAW = 0x10, |
| 605 | TRACE_ITER_HEX = 0x20, |
| 606 | TRACE_ITER_BIN = 0x40, |
| 607 | TRACE_ITER_BLOCK = 0x80, |
| 608 | TRACE_ITER_STACKTRACE = 0x100, |
Li Zefan | 2cbafd6 | 2009-12-08 11:16:26 +0800 | [diff] [blame] | 609 | TRACE_ITER_PRINTK = 0x200, |
| 610 | TRACE_ITER_PREEMPTONLY = 0x400, |
| 611 | TRACE_ITER_BRANCH = 0x800, |
| 612 | TRACE_ITER_ANNOTATE = 0x1000, |
| 613 | TRACE_ITER_USERSTACKTRACE = 0x2000, |
| 614 | TRACE_ITER_SYM_USEROBJ = 0x4000, |
| 615 | TRACE_ITER_PRINTK_MSGONLY = 0x8000, |
| 616 | TRACE_ITER_CONTEXT_INFO = 0x10000, /* Print pid/cpu/time */ |
| 617 | TRACE_ITER_LATENCY_FMT = 0x20000, |
| 618 | TRACE_ITER_SLEEP_TIME = 0x40000, |
| 619 | TRACE_ITER_GRAPH_TIME = 0x80000, |
Ingo Molnar | 4e65551 | 2008-05-12 21:20:52 +0200 | [diff] [blame] | 620 | }; |
| 621 | |
Frederic Weisbecker | 15e6cb3 | 2008-11-11 07:14:25 +0100 | [diff] [blame] | 622 | /* |
| 623 | * TRACE_ITER_SYM_MASK masks the options in trace_flags that |
| 624 | * control the output of kernel symbols. |
| 625 | */ |
| 626 | #define TRACE_ITER_SYM_MASK \ |
| 627 | (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR) |
| 628 | |
Frédéric Weisbecker | 43a1538 | 2008-09-21 20:16:30 +0200 | [diff] [blame] | 629 | extern struct tracer nop_trace; |
| 630 | |
Steven Rostedt | 8f0a056 | 2008-11-03 23:15:55 -0500 | [diff] [blame] | 631 | /** |
| 632 | * ftrace_preempt_disable - disable preemption scheduler safe |
| 633 | * |
| 634 | * When tracing can happen inside the scheduler, there exists |
| 635 | * cases that the tracing might happen before the need_resched |
| 636 | * flag is checked. If this happens and the tracer calls |
| 637 | * preempt_enable (after a disable), a schedule might take place |
| 638 | * causing an infinite recursion. |
| 639 | * |
Wenji Huang | 57794a9 | 2009-02-06 17:33:27 +0800 | [diff] [blame] | 640 | * To prevent this, we read the need_resched flag before |
Steven Rostedt | 8f0a056 | 2008-11-03 23:15:55 -0500 | [diff] [blame] | 641 | * disabling preemption. When we want to enable preemption we |
| 642 | * check the flag, if it is set, then we call preempt_enable_no_resched. |
| 643 | * Otherwise, we call preempt_enable. |
| 644 | * |
Wenji Huang | 57794a9 | 2009-02-06 17:33:27 +0800 | [diff] [blame] | 645 | * The rational for doing the above is that if need_resched is set |
Steven Rostedt | 8f0a056 | 2008-11-03 23:15:55 -0500 | [diff] [blame] | 646 | * and we have yet to reschedule, we are either in an atomic location |
| 647 | * (where we do not need to check for scheduling) or we are inside |
| 648 | * the scheduler and do not want to resched. |
| 649 | */ |
| 650 | static inline int ftrace_preempt_disable(void) |
| 651 | { |
| 652 | int resched; |
| 653 | |
| 654 | resched = need_resched(); |
| 655 | preempt_disable_notrace(); |
| 656 | |
| 657 | return resched; |
| 658 | } |
| 659 | |
| 660 | /** |
| 661 | * ftrace_preempt_enable - enable preemption scheduler safe |
| 662 | * @resched: the return value from ftrace_preempt_disable |
| 663 | * |
| 664 | * This is a scheduler safe way to enable preemption and not miss |
| 665 | * any preemption checks. The disabled saved the state of preemption. |
Wenji Huang | 57794a9 | 2009-02-06 17:33:27 +0800 | [diff] [blame] | 666 | * If resched is set, then we are either inside an atomic or |
Steven Rostedt | 8f0a056 | 2008-11-03 23:15:55 -0500 | [diff] [blame] | 667 | * are inside the scheduler (we would have already scheduled |
| 668 | * otherwise). In this case, we do not want to call normal |
| 669 | * preempt_enable, but preempt_enable_no_resched instead. |
| 670 | */ |
| 671 | static inline void ftrace_preempt_enable(int resched) |
| 672 | { |
| 673 | if (resched) |
| 674 | preempt_enable_no_resched_notrace(); |
| 675 | else |
| 676 | preempt_enable_notrace(); |
| 677 | } |
| 678 | |
Steven Rostedt | 2ed84ee | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 679 | #ifdef CONFIG_BRANCH_TRACER |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 680 | extern int enable_branch_tracing(struct trace_array *tr); |
| 681 | extern void disable_branch_tracing(void); |
| 682 | static inline int trace_branch_enable(struct trace_array *tr) |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 683 | { |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 684 | if (trace_flags & TRACE_ITER_BRANCH) |
| 685 | return enable_branch_tracing(tr); |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 686 | return 0; |
| 687 | } |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 688 | static inline void trace_branch_disable(void) |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 689 | { |
| 690 | /* due to races, always disable */ |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 691 | disable_branch_tracing(); |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 692 | } |
| 693 | #else |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 694 | static inline int trace_branch_enable(struct trace_array *tr) |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 695 | { |
| 696 | return 0; |
| 697 | } |
Steven Rostedt | 9f029e8 | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 698 | static inline void trace_branch_disable(void) |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 699 | { |
| 700 | } |
Steven Rostedt | 2ed84ee | 2008-11-12 15:24:24 -0500 | [diff] [blame] | 701 | #endif /* CONFIG_BRANCH_TRACER */ |
Steven Rostedt | 52f232c | 2008-11-12 00:14:40 -0500 | [diff] [blame] | 702 | |
Steven Rostedt | 1852fcc | 2009-03-11 14:33:00 -0400 | [diff] [blame] | 703 | /* set ring buffers to default size if not already done so */ |
| 704 | int tracing_update_buffers(void); |
| 705 | |
Steven Rostedt | fd99498 | 2009-02-28 02:41:25 -0500 | [diff] [blame] | 706 | /* trace event type bit fields, not numeric */ |
| 707 | enum { |
| 708 | TRACE_EVENT_TYPE_PRINTF = 1, |
| 709 | TRACE_EVENT_TYPE_RAW = 2, |
| 710 | }; |
| 711 | |
Tom Zanussi | cf027f6 | 2009-03-22 03:30:39 -0500 | [diff] [blame] | 712 | struct ftrace_event_field { |
| 713 | struct list_head link; |
| 714 | char *name; |
| 715 | char *type; |
Li Zefan | aa38e9f | 2009-08-07 10:33:02 +0800 | [diff] [blame] | 716 | int filter_type; |
Tom Zanussi | cf027f6 | 2009-03-22 03:30:39 -0500 | [diff] [blame] | 717 | int offset; |
| 718 | int size; |
Tom Zanussi | a118e4d | 2009-04-28 03:04:53 -0500 | [diff] [blame] | 719 | int is_signed; |
Tom Zanussi | cf027f6 | 2009-03-22 03:30:39 -0500 | [diff] [blame] | 720 | }; |
| 721 | |
Tom Zanussi | 30e673b | 2009-04-28 03:04:47 -0500 | [diff] [blame] | 722 | struct event_filter { |
| 723 | int n_preds; |
| 724 | struct filter_pred **preds; |
Tom Zanussi | 8b37256 | 2009-04-28 03:04:59 -0500 | [diff] [blame] | 725 | char *filter_string; |
Tom Zanussi | 30e673b | 2009-04-28 03:04:47 -0500 | [diff] [blame] | 726 | }; |
| 727 | |
Tom Zanussi | cfb180f | 2009-03-22 03:31:17 -0500 | [diff] [blame] | 728 | struct event_subsystem { |
| 729 | struct list_head list; |
| 730 | const char *name; |
| 731 | struct dentry *entry; |
Li Zefan | 1f9963c | 2009-07-20 10:20:53 +0800 | [diff] [blame] | 732 | struct event_filter *filter; |
Xiao Guangrong | dc82ec98a | 2009-07-09 16:22:22 +0800 | [diff] [blame] | 733 | int nr_events; |
Tom Zanussi | cfb180f | 2009-03-22 03:31:17 -0500 | [diff] [blame] | 734 | }; |
| 735 | |
Tom Zanussi | 7ce7e42 | 2009-03-22 03:31:04 -0500 | [diff] [blame] | 736 | struct filter_pred; |
Frederic Weisbecker | 1889d20 | 2009-09-24 21:10:44 +0200 | [diff] [blame] | 737 | struct regex; |
Tom Zanussi | 7ce7e42 | 2009-03-22 03:31:04 -0500 | [diff] [blame] | 738 | |
Tom Zanussi | 8b37256 | 2009-04-28 03:04:59 -0500 | [diff] [blame] | 739 | typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event, |
| 740 | int val1, int val2); |
Tom Zanussi | 7ce7e42 | 2009-03-22 03:31:04 -0500 | [diff] [blame] | 741 | |
Frederic Weisbecker | 1889d20 | 2009-09-24 21:10:44 +0200 | [diff] [blame] | 742 | typedef int (*regex_match_func)(char *str, struct regex *r, int len); |
| 743 | |
Frederic Weisbecker | 3f6fe06 | 2009-09-24 21:31:51 +0200 | [diff] [blame] | 744 | enum regex_type { |
Li Zefan | b0f1a59 | 2009-10-15 11:21:12 +0800 | [diff] [blame] | 745 | MATCH_FULL = 0, |
Frederic Weisbecker | 3f6fe06 | 2009-09-24 21:31:51 +0200 | [diff] [blame] | 746 | MATCH_FRONT_ONLY, |
| 747 | MATCH_MIDDLE_ONLY, |
| 748 | MATCH_END_ONLY, |
Tom Zanussi | 7ce7e42 | 2009-03-22 03:31:04 -0500 | [diff] [blame] | 749 | }; |
| 750 | |
Frederic Weisbecker | 1889d20 | 2009-09-24 21:10:44 +0200 | [diff] [blame] | 751 | struct regex { |
| 752 | char pattern[MAX_FILTER_STR_VAL]; |
| 753 | int len; |
| 754 | int field_len; |
| 755 | regex_match_func match; |
| 756 | }; |
| 757 | |
Tom Zanussi | cf027f6 | 2009-03-22 03:30:39 -0500 | [diff] [blame] | 758 | struct filter_pred { |
Frederic Weisbecker | 1889d20 | 2009-09-24 21:10:44 +0200 | [diff] [blame] | 759 | filter_pred_fn_t fn; |
| 760 | u64 val; |
| 761 | struct regex regex; |
| 762 | char *field_name; |
| 763 | int offset; |
| 764 | int not; |
| 765 | int op; |
| 766 | int pop_n; |
Steven Rostedt | c32e827 | 2009-02-27 19:12:30 -0500 | [diff] [blame] | 767 | }; |
| 768 | |
Frederic Weisbecker | 3f6fe06 | 2009-09-24 21:31:51 +0200 | [diff] [blame] | 769 | extern enum regex_type |
| 770 | filter_parse_regex(char *buff, int len, char **search, int *not); |
Tom Zanussi | 8b37256 | 2009-04-28 03:04:59 -0500 | [diff] [blame] | 771 | extern void print_event_filter(struct ftrace_event_call *call, |
Tom Zanussi | 4bda2d5 | 2009-03-24 02:14:31 -0500 | [diff] [blame] | 772 | struct trace_seq *s); |
Tom Zanussi | 8b37256 | 2009-04-28 03:04:59 -0500 | [diff] [blame] | 773 | extern int apply_event_filter(struct ftrace_event_call *call, |
| 774 | char *filter_string); |
| 775 | extern int apply_subsystem_event_filter(struct event_subsystem *system, |
| 776 | char *filter_string); |
| 777 | extern void print_subsystem_event_filter(struct event_subsystem *system, |
Tom Zanussi | ac1adc5 | 2009-04-17 00:27:08 -0500 | [diff] [blame] | 778 | struct trace_seq *s); |
Li Zefan | aa38e9f | 2009-08-07 10:33:02 +0800 | [diff] [blame] | 779 | extern int filter_assign_type(const char *type); |
Tom Zanussi | 7ce7e42 | 2009-03-22 03:31:04 -0500 | [diff] [blame] | 780 | |
Tom Zanussi | eb02ce0 | 2009-04-08 03:15:54 -0500 | [diff] [blame] | 781 | static inline int |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 782 | filter_check_discard(struct ftrace_event_call *call, void *rec, |
Tom Zanussi | eb02ce0 | 2009-04-08 03:15:54 -0500 | [diff] [blame] | 783 | struct ring_buffer *buffer, |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 784 | struct ring_buffer_event *event) |
| 785 | { |
Li Zefan | 6fb2915 | 2009-10-15 11:21:42 +0800 | [diff] [blame] | 786 | if (unlikely(call->filter_active) && |
| 787 | !filter_match_preds(call->filter, rec)) { |
Tom Zanussi | eb02ce0 | 2009-04-08 03:15:54 -0500 | [diff] [blame] | 788 | ring_buffer_discard_commit(buffer, event); |
| 789 | return 1; |
| 790 | } |
| 791 | |
| 792 | return 0; |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 793 | } |
| 794 | |
Li Zefan | 20c8928 | 2009-05-06 10:33:45 +0800 | [diff] [blame] | 795 | extern struct mutex event_mutex; |
Steven Rostedt | a59fd60 | 2009-04-10 13:52:20 -0400 | [diff] [blame] | 796 | extern struct list_head ftrace_events; |
Peter Zijlstra | ac199db | 2009-03-19 20:26:15 +0100 | [diff] [blame] | 797 | |
Steven Rostedt | e9fb2b6 | 2009-03-12 14:19:25 -0400 | [diff] [blame] | 798 | extern const char *__start___trace_bprintk_fmt[]; |
| 799 | extern const char *__stop___trace_bprintk_fmt[]; |
| 800 | |
Steven Rostedt | 4e5292e | 2009-09-12 19:26:21 -0400 | [diff] [blame] | 801 | #undef FTRACE_ENTRY |
| 802 | #define FTRACE_ENTRY(call, struct_name, id, tstruct, print) \ |
Jeff Mahoney | 86c38a3 | 2010-02-24 13:59:23 -0500 | [diff] [blame] | 803 | extern struct ftrace_event_call \ |
| 804 | __attribute__((__aligned__(4))) event_##call; |
Steven Rostedt | 4e5292e | 2009-09-12 19:26:21 -0400 | [diff] [blame] | 805 | #undef FTRACE_ENTRY_DUP |
| 806 | #define FTRACE_ENTRY_DUP(call, struct_name, id, tstruct, print) \ |
| 807 | FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print)) |
| 808 | #include "trace_entries.h" |
Tom Zanussi | e1112b4 | 2009-03-31 00:48:49 -0500 | [diff] [blame] | 809 | |
Steven Rostedt | bc0c38d | 2008-05-12 21:20:42 +0200 | [diff] [blame] | 810 | #endif /* _LINUX_KERNEL_TRACE_H */ |