Branch data Line data Source code
1 : : /*
2 : : * This file defines the trace event structures that go into the ring
3 : : * buffer directly. They are created via macros so that changes for them
4 : : * appear in the format file. Using macros will automate this process.
5 : : *
6 : : * The macro used to create a ftrace data structure is:
7 : : *
8 : : * FTRACE_ENTRY( name, struct_name, id, structure, print )
9 : : *
10 : : * @name: the name used the event name, as well as the name of
11 : : * the directory that holds the format file.
12 : : *
13 : : * @struct_name: the name of the structure that is created.
14 : : *
15 : : * @id: The event identifier that is used to detect what event
16 : : * this is from the ring buffer.
17 : : *
18 : : * @structure: the structure layout
19 : : *
20 : : * - __field( type, item )
21 : : * This is equivalent to declaring
22 : : * type item;
23 : : * in the structure.
24 : : * - __array( type, item, size )
25 : : * This is equivalent to declaring
26 : : * type item[size];
27 : : * in the structure.
28 : : *
29 : : * * for structures within structures, the format of the internal
30 : : * structure is laid out. This allows the internal structure
31 : : * to be deciphered for the format file. Although these macros
32 : : * may become out of sync with the internal structure, they
33 : : * will create a compile error if it happens. Since the
34 : : * internel structures are just tracing helpers, this is not
35 : : * an issue.
36 : : *
37 : : * When an internal structure is used, it should use:
38 : : *
39 : : * __field_struct( type, item )
40 : : *
41 : : * instead of __field. This will prevent it from being shown in
42 : : * the output file. The fields in the structure should use.
43 : : *
44 : : * __field_desc( type, container, item )
45 : : * __array_desc( type, container, item, len )
46 : : *
47 : : * type, item and len are the same as __field and __array, but
48 : : * container is added. This is the name of the item in
49 : : * __field_struct that this is describing.
50 : : *
51 : : *
52 : : * @print: the print format shown to users in the format file.
53 : : */
54 : :
55 : : /*
56 : : * Function trace entry - function address and parent function address:
57 : : */
58 [ # # ]: 0 : FTRACE_ENTRY_REG(function, ftrace_entry,
59 : :
60 : : TRACE_FN,
61 : :
62 : : F_STRUCT(
63 : : __field( unsigned long, ip )
64 : : __field( unsigned long, parent_ip )
65 : : ),
66 : :
67 : : F_printk(" %lx <-- %lx", __entry->ip, __entry->parent_ip),
68 : :
69 : : FILTER_TRACE_FN,
70 : :
71 : : perf_ftrace_event_register
72 : : );
73 : :
74 : : /* Function call entry */
75 [ # # ]: 0 : FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry,
76 : :
77 : : TRACE_GRAPH_ENT,
78 : :
79 : : F_STRUCT(
80 : : __field_struct( struct ftrace_graph_ent, graph_ent )
81 : : __field_desc( unsigned long, graph_ent, func )
82 : : __field_desc( int, graph_ent, depth )
83 : : ),
84 : :
85 : : F_printk("--> %lx (%d)", __entry->func, __entry->depth),
86 : :
87 : : FILTER_OTHER
88 : : );
89 : :
90 : : /* Function return entry */
91 [ # # ][ # # ]: 0 : FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry,
[ # # ][ # # ]
92 : :
93 : : TRACE_GRAPH_RET,
94 : :
95 : : F_STRUCT(
96 : : __field_struct( struct ftrace_graph_ret, ret )
97 : : __field_desc( unsigned long, ret, func )
98 : : __field_desc( unsigned long long, ret, calltime)
99 : : __field_desc( unsigned long long, ret, rettime )
100 : : __field_desc( unsigned long, ret, overrun )
101 : : __field_desc( int, ret, depth )
102 : : ),
103 : :
104 : : F_printk("<-- %lx (%d) (start: %llx end: %llx) over: %d",
105 : : __entry->func, __entry->depth,
106 : : __entry->calltime, __entry->rettime,
107 : : __entry->depth),
108 : :
109 : : FILTER_OTHER
110 : : );
111 : :
112 : : /*
113 : : * Context switch trace entry - which task (and prio) we switched from/to:
114 : : *
115 : : * This is used for both wakeup and context switches. We only want
116 : : * to create one structure, but we need two outputs for it.
117 : : */
118 : : #define FTRACE_CTX_FIELDS \
119 : : __field( unsigned int, prev_pid ) \
120 : : __field( unsigned int, next_pid ) \
121 : : __field( unsigned int, next_cpu ) \
122 : : __field( unsigned char, prev_prio ) \
123 : : __field( unsigned char, prev_state ) \
124 : : __field( unsigned char, next_prio ) \
125 : : __field( unsigned char, next_state )
126 : :
127 [ # # ][ # # ]: 0 : FTRACE_ENTRY(context_switch, ctx_switch_entry,
[ # # ][ # # ]
[ # # ][ # # ]
128 : :
129 : : TRACE_CTX,
130 : :
131 : : F_STRUCT(
132 : : FTRACE_CTX_FIELDS
133 : : ),
134 : :
135 : : F_printk("%u:%u:%u ==> %u:%u:%u [%03u]",
136 : : __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
137 : : __entry->next_pid, __entry->next_prio, __entry->next_state,
138 : : __entry->next_cpu),
139 : :
140 : : FILTER_OTHER
141 : : );
142 : :
143 : : /*
144 : : * FTRACE_ENTRY_DUP only creates the format file, it will not
145 : : * create another structure.
146 : : */
147 [ # # ][ # # ]: 0 : FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry,
[ # # ][ # # ]
[ # # ][ # # ]
148 : :
149 : : TRACE_WAKE,
150 : :
151 : : F_STRUCT(
152 : : FTRACE_CTX_FIELDS
153 : : ),
154 : :
155 : : F_printk("%u:%u:%u ==+ %u:%u:%u [%03u]",
156 : : __entry->prev_pid, __entry->prev_prio, __entry->prev_state,
157 : : __entry->next_pid, __entry->next_prio, __entry->next_state,
158 : : __entry->next_cpu),
159 : :
160 : : FILTER_OTHER
161 : : );
162 : :
163 : : /*
164 : : * Stack-trace entry:
165 : : */
166 : :
167 : : #define FTRACE_STACK_ENTRIES 8
168 : :
169 : : #ifndef CONFIG_64BIT
170 : : # define IP_FMT "%08lx"
171 : : #else
172 : : # define IP_FMT "%016lx"
173 : : #endif
174 : :
175 [ # # ]: 0 : FTRACE_ENTRY(kernel_stack, stack_entry,
176 : :
177 : : TRACE_STACK,
178 : :
179 : : F_STRUCT(
180 : : __field( int, size )
181 : : __dynamic_array(unsigned long, caller )
182 : : ),
183 : :
184 : : F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
185 : : "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
186 : : "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
187 : : __entry->caller[0], __entry->caller[1], __entry->caller[2],
188 : : __entry->caller[3], __entry->caller[4], __entry->caller[5],
189 : : __entry->caller[6], __entry->caller[7]),
190 : :
191 : : FILTER_OTHER
192 : : );
193 : :
194 [ # # ]: 0 : FTRACE_ENTRY(user_stack, userstack_entry,
195 : :
196 : : TRACE_USER_STACK,
197 : :
198 : : F_STRUCT(
199 : : __field( unsigned int, tgid )
200 : : __array( unsigned long, caller, FTRACE_STACK_ENTRIES )
201 : : ),
202 : :
203 : : F_printk("\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
204 : : "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n"
205 : : "\t=> (" IP_FMT ")\n\t=> (" IP_FMT ")\n",
206 : : __entry->caller[0], __entry->caller[1], __entry->caller[2],
207 : : __entry->caller[3], __entry->caller[4], __entry->caller[5],
208 : : __entry->caller[6], __entry->caller[7]),
209 : :
210 : : FILTER_OTHER
211 : : );
212 : :
213 : : /*
214 : : * trace_printk entry:
215 : : */
216 [ # # ][ # # ]: 0 : FTRACE_ENTRY(bprint, bprint_entry,
217 : :
218 : : TRACE_BPRINT,
219 : :
220 : : F_STRUCT(
221 : : __field( unsigned long, ip )
222 : : __field( const char *, fmt )
223 : : __dynamic_array( u32, buf )
224 : : ),
225 : :
226 : : F_printk("%pf: %s",
227 : : (void *)__entry->ip, __entry->fmt),
228 : :
229 : : FILTER_OTHER
230 : : );
231 : :
232 [ # # ]: 0 : FTRACE_ENTRY(print, print_entry,
233 : :
234 : : TRACE_PRINT,
235 : :
236 : : F_STRUCT(
237 : : __field( unsigned long, ip )
238 : : __dynamic_array( char, buf )
239 : : ),
240 : :
241 : : F_printk("%pf: %s",
242 : : (void *)__entry->ip, __entry->buf),
243 : :
244 : : FILTER_OTHER
245 : : );
246 : :
247 [ # # ]: 0 : FTRACE_ENTRY(bputs, bputs_entry,
248 : :
249 : : TRACE_BPUTS,
250 : :
251 : : F_STRUCT(
252 : : __field( unsigned long, ip )
253 : : __field( const char *, str )
254 : : ),
255 : :
256 : : F_printk("%pf: %s",
257 : : (void *)__entry->ip, __entry->str),
258 : :
259 : : FILTER_OTHER
260 : : );
261 : :
262 [ # # ][ # # ]: 0 : FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw,
[ # # ][ # # ]
[ # # ]
263 : :
264 : : TRACE_MMIO_RW,
265 : :
266 : : F_STRUCT(
267 : : __field_struct( struct mmiotrace_rw, rw )
268 : : __field_desc( resource_size_t, rw, phys )
269 : : __field_desc( unsigned long, rw, value )
270 : : __field_desc( unsigned long, rw, pc )
271 : : __field_desc( int, rw, map_id )
272 : : __field_desc( unsigned char, rw, opcode )
273 : : __field_desc( unsigned char, rw, width )
274 : : ),
275 : :
276 : : F_printk("%lx %lx %lx %d %x %x",
277 : : (unsigned long)__entry->phys, __entry->value, __entry->pc,
278 : : __entry->map_id, __entry->opcode, __entry->width),
279 : :
280 : : FILTER_OTHER
281 : : );
282 : :
283 [ # # ][ # # ]: 0 : FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map,
[ # # ][ # # ]
284 : :
285 : : TRACE_MMIO_MAP,
286 : :
287 : : F_STRUCT(
288 : : __field_struct( struct mmiotrace_map, map )
289 : : __field_desc( resource_size_t, map, phys )
290 : : __field_desc( unsigned long, map, virt )
291 : : __field_desc( unsigned long, map, len )
292 : : __field_desc( int, map, map_id )
293 : : __field_desc( unsigned char, map, opcode )
294 : : ),
295 : :
296 : : F_printk("%lx %lx %lx %d %x",
297 : : (unsigned long)__entry->phys, __entry->virt, __entry->len,
298 : : __entry->map_id, __entry->opcode),
299 : :
300 : : FILTER_OTHER
301 : : );
302 : :
303 : :
304 : : #define TRACE_FUNC_SIZE 30
305 : : #define TRACE_FILE_SIZE 20
306 : :
307 [ # # ][ # # ]: 0 : FTRACE_ENTRY(branch, trace_branch,
[ # # ]
308 : :
309 : : TRACE_BRANCH,
310 : :
311 : : F_STRUCT(
312 : : __field( unsigned int, line )
313 : : __array( char, func, TRACE_FUNC_SIZE+1 )
314 : : __array( char, file, TRACE_FILE_SIZE+1 )
315 : : __field( char, correct )
316 : : ),
317 : :
318 : : F_printk("%u:%s:%s (%u)",
319 : : __entry->line,
320 : : __entry->func, __entry->file, __entry->correct),
321 : :
322 : : FILTER_OTHER
323 : : );
324 : :
|
