Commit | Line | Data |
---|---|---|
0a1c49db SR |
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 | * | |
d7315094 SR |
29 | * * for structures within structures, the format of the internal |
30 | * structure is layed 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 | * | |
0a1c49db SR |
52 | * @print: the print format shown to users in the format file. |
53 | */ | |
54 | ||
55 | /* | |
56 | * Function trace entry - function address and parent function addres: | |
57 | */ | |
58 | FTRACE_ENTRY(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 | ||
70 | /* Function call entry */ | |
71 | FTRACE_ENTRY(funcgraph_entry, ftrace_graph_ent_entry, | |
72 | ||
73 | TRACE_GRAPH_ENT, | |
74 | ||
75 | F_STRUCT( | |
d7315094 SR |
76 | __field_struct( struct ftrace_graph_ent, graph_ent ) |
77 | __field_desc( unsigned long, graph_ent, func ) | |
78 | __field_desc( int, graph_ent, depth ) | |
0a1c49db SR |
79 | ), |
80 | ||
c16de8fd | 81 | F_printk("--> %lx (%d)", __entry->func, __entry->depth) |
0a1c49db SR |
82 | ); |
83 | ||
84 | /* Function return entry */ | |
85 | FTRACE_ENTRY(funcgraph_exit, ftrace_graph_ret_entry, | |
86 | ||
87 | TRACE_GRAPH_RET, | |
88 | ||
89 | F_STRUCT( | |
d7315094 SR |
90 | __field_struct( struct ftrace_graph_ret, ret ) |
91 | __field_desc( unsigned long, ret, func ) | |
92 | __field_desc( unsigned long long, ret, calltime) | |
93 | __field_desc( unsigned long long, ret, rettime ) | |
94 | __field_desc( unsigned long, ret, overrun ) | |
95 | __field_desc( int, ret, depth ) | |
0a1c49db SR |
96 | ), |
97 | ||
98 | F_printk("<-- %lx (%d) (start: %llx end: %llx) over: %d", | |
99 | __entry->func, __entry->depth, | |
c16de8fd LZ |
100 | __entry->calltime, __entry->rettime, |
101 | __entry->depth) | |
0a1c49db SR |
102 | ); |
103 | ||
104 | /* | |
105 | * Context switch trace entry - which task (and prio) we switched from/to: | |
106 | * | |
107 | * This is used for both wakeup and context switches. We only want | |
108 | * to create one structure, but we need two outputs for it. | |
109 | */ | |
110 | #define FTRACE_CTX_FIELDS \ | |
111 | __field( unsigned int, prev_pid ) \ | |
112 | __field( unsigned char, prev_prio ) \ | |
113 | __field( unsigned char, prev_state ) \ | |
114 | __field( unsigned int, next_pid ) \ | |
115 | __field( unsigned char, next_prio ) \ | |
116 | __field( unsigned char, next_state ) \ | |
117 | __field( unsigned int, next_cpu ) | |
118 | ||
0a1c49db SR |
119 | FTRACE_ENTRY(context_switch, ctx_switch_entry, |
120 | ||
121 | TRACE_CTX, | |
122 | ||
123 | F_STRUCT( | |
124 | FTRACE_CTX_FIELDS | |
125 | ), | |
126 | ||
c16de8fd | 127 | F_printk("%u:%u:%u ==> %u:%u:%u [%03u]", |
0a1c49db SR |
128 | __entry->prev_pid, __entry->prev_prio, __entry->prev_state, |
129 | __entry->next_pid, __entry->next_prio, __entry->next_state, | |
130 | __entry->next_cpu | |
131 | ) | |
132 | ); | |
133 | ||
134 | /* | |
135 | * FTRACE_ENTRY_DUP only creates the format file, it will not | |
136 | * create another structure. | |
137 | */ | |
138 | FTRACE_ENTRY_DUP(wakeup, ctx_switch_entry, | |
139 | ||
140 | TRACE_WAKE, | |
141 | ||
142 | F_STRUCT( | |
143 | FTRACE_CTX_FIELDS | |
144 | ), | |
145 | ||
146 | F_printk("%u:%u:%u ==+ %u:%u:%u [%03u]", | |
147 | __entry->prev_pid, __entry->prev_prio, __entry->prev_state, | |
148 | __entry->next_pid, __entry->next_prio, __entry->next_state, | |
149 | __entry->next_cpu | |
150 | ) | |
151 | ); | |
152 | ||
153 | /* | |
154 | * Special (free-form) trace entry: | |
155 | */ | |
156 | FTRACE_ENTRY(special, special_entry, | |
157 | ||
158 | TRACE_SPECIAL, | |
159 | ||
160 | F_STRUCT( | |
161 | __field( unsigned long, arg1 ) | |
162 | __field( unsigned long, arg2 ) | |
163 | __field( unsigned long, arg3 ) | |
164 | ), | |
165 | ||
166 | F_printk("(%08lx) (%08lx) (%08lx)", | |
167 | __entry->arg1, __entry->arg2, __entry->arg3) | |
168 | ); | |
169 | ||
170 | /* | |
171 | * Stack-trace entry: | |
172 | */ | |
173 | ||
174 | #define FTRACE_STACK_ENTRIES 8 | |
175 | ||
176 | FTRACE_ENTRY(kernel_stack, stack_entry, | |
177 | ||
178 | TRACE_STACK, | |
179 | ||
180 | F_STRUCT( | |
181 | __array( unsigned long, caller, FTRACE_STACK_ENTRIES ) | |
182 | ), | |
183 | ||
184 | F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n" | |
185 | "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n", | |
186 | __entry->caller[0], __entry->caller[1], __entry->caller[2], | |
187 | __entry->caller[3], __entry->caller[4], __entry->caller[5], | |
188 | __entry->caller[6], __entry->caller[7]) | |
189 | ); | |
190 | ||
191 | FTRACE_ENTRY(user_stack, userstack_entry, | |
192 | ||
193 | TRACE_USER_STACK, | |
194 | ||
195 | F_STRUCT( | |
196 | __field( unsigned int, tgid ) | |
197 | __array( unsigned long, caller, FTRACE_STACK_ENTRIES ) | |
198 | ), | |
199 | ||
200 | F_printk("\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n" | |
201 | "\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n\t=> (%08lx)\n", | |
202 | __entry->caller[0], __entry->caller[1], __entry->caller[2], | |
203 | __entry->caller[3], __entry->caller[4], __entry->caller[5], | |
204 | __entry->caller[6], __entry->caller[7]) | |
205 | ); | |
206 | ||
207 | /* | |
208 | * trace_printk entry: | |
209 | */ | |
210 | FTRACE_ENTRY(bprint, bprint_entry, | |
211 | ||
212 | TRACE_BPRINT, | |
213 | ||
214 | F_STRUCT( | |
215 | __field( unsigned long, ip ) | |
216 | __field( const char *, fmt ) | |
217 | __dynamic_array( u32, buf ) | |
218 | ), | |
219 | ||
220 | F_printk("%08lx fmt:%p", | |
221 | __entry->ip, __entry->fmt) | |
222 | ); | |
223 | ||
224 | FTRACE_ENTRY(print, print_entry, | |
225 | ||
226 | TRACE_PRINT, | |
227 | ||
228 | F_STRUCT( | |
229 | __field( unsigned long, ip ) | |
230 | __dynamic_array( char, buf ) | |
231 | ), | |
232 | ||
233 | F_printk("%08lx %s", | |
234 | __entry->ip, __entry->buf) | |
235 | ); | |
236 | ||
237 | FTRACE_ENTRY(mmiotrace_rw, trace_mmiotrace_rw, | |
238 | ||
239 | TRACE_MMIO_RW, | |
240 | ||
241 | F_STRUCT( | |
d7315094 SR |
242 | __field_struct( struct mmiotrace_rw, rw ) |
243 | __field_desc( resource_size_t, rw, phys ) | |
244 | __field_desc( unsigned long, rw, value ) | |
245 | __field_desc( unsigned long, rw, pc ) | |
246 | __field_desc( int, rw, map_id ) | |
247 | __field_desc( unsigned char, rw, opcode ) | |
248 | __field_desc( unsigned char, rw, width ) | |
0a1c49db SR |
249 | ), |
250 | ||
c16de8fd LZ |
251 | F_printk("%lx %lx %lx %d %x %x", |
252 | (unsigned long)__entry->phys, __entry->value, __entry->pc, | |
0a1c49db SR |
253 | __entry->map_id, __entry->opcode, __entry->width) |
254 | ); | |
255 | ||
256 | FTRACE_ENTRY(mmiotrace_map, trace_mmiotrace_map, | |
257 | ||
258 | TRACE_MMIO_MAP, | |
259 | ||
260 | F_STRUCT( | |
d7315094 SR |
261 | __field_struct( struct mmiotrace_map, map ) |
262 | __field_desc( resource_size_t, map, phys ) | |
263 | __field_desc( unsigned long, map, virt ) | |
264 | __field_desc( unsigned long, map, len ) | |
265 | __field_desc( int, map, map_id ) | |
266 | __field_desc( unsigned char, map, opcode ) | |
0a1c49db SR |
267 | ), |
268 | ||
c16de8fd LZ |
269 | F_printk("%lx %lx %lx %d %x", |
270 | (unsigned long)__entry->phys, __entry->virt, __entry->len, | |
0a1c49db SR |
271 | __entry->map_id, __entry->opcode) |
272 | ); | |
273 | ||
274 | FTRACE_ENTRY(boot_call, trace_boot_call, | |
275 | ||
276 | TRACE_BOOT_CALL, | |
277 | ||
278 | F_STRUCT( | |
d7315094 SR |
279 | __field_struct( struct boot_trace_call, boot_call ) |
280 | __field_desc( pid_t, boot_call, caller ) | |
281 | __array_desc( char, boot_call, func, KSYM_SYMBOL_LEN) | |
0a1c49db SR |
282 | ), |
283 | ||
284 | F_printk("%d %s", __entry->caller, __entry->func) | |
285 | ); | |
286 | ||
287 | FTRACE_ENTRY(boot_ret, trace_boot_ret, | |
288 | ||
289 | TRACE_BOOT_RET, | |
290 | ||
291 | F_STRUCT( | |
d7315094 SR |
292 | __field_struct( struct boot_trace_ret, boot_ret ) |
293 | __array_desc( char, boot_ret, func, KSYM_SYMBOL_LEN) | |
294 | __field_desc( int, boot_ret, result ) | |
295 | __field_desc( unsigned long, boot_ret, duration ) | |
0a1c49db SR |
296 | ), |
297 | ||
298 | F_printk("%s %d %lx", | |
299 | __entry->func, __entry->result, __entry->duration) | |
300 | ); | |
301 | ||
302 | #define TRACE_FUNC_SIZE 30 | |
303 | #define TRACE_FILE_SIZE 20 | |
304 | ||
305 | FTRACE_ENTRY(branch, trace_branch, | |
306 | ||
307 | TRACE_BRANCH, | |
308 | ||
309 | F_STRUCT( | |
310 | __field( unsigned int, line ) | |
311 | __array( char, func, TRACE_FUNC_SIZE+1 ) | |
312 | __array( char, file, TRACE_FILE_SIZE+1 ) | |
313 | __field( char, correct ) | |
314 | ), | |
315 | ||
316 | F_printk("%u:%s:%s (%u)", | |
317 | __entry->line, | |
318 | __entry->func, __entry->file, __entry->correct) | |
319 | ); | |
320 | ||
321 | FTRACE_ENTRY(hw_branch, hw_branch_entry, | |
322 | ||
323 | TRACE_HW_BRANCHES, | |
324 | ||
325 | F_STRUCT( | |
326 | __field( u64, from ) | |
327 | __field( u64, to ) | |
328 | ), | |
329 | ||
330 | F_printk("from: %llx to: %llx", __entry->from, __entry->to) | |
331 | ); | |
332 | ||
0a1c49db SR |
333 | FTRACE_ENTRY(kmem_alloc, kmemtrace_alloc_entry, |
334 | ||
335 | TRACE_KMEM_ALLOC, | |
336 | ||
337 | F_STRUCT( | |
338 | __field( enum kmemtrace_type_id, type_id ) | |
339 | __field( unsigned long, call_site ) | |
340 | __field( const void *, ptr ) | |
341 | __field( size_t, bytes_req ) | |
342 | __field( size_t, bytes_alloc ) | |
343 | __field( gfp_t, gfp_flags ) | |
344 | __field( int, node ) | |
345 | ), | |
346 | ||
c16de8fd | 347 | F_printk("type:%u call_site:%lx ptr:%p req:%zi alloc:%zi" |
0a1c49db SR |
348 | " flags:%x node:%d", |
349 | __entry->type_id, __entry->call_site, __entry->ptr, | |
350 | __entry->bytes_req, __entry->bytes_alloc, | |
351 | __entry->gfp_flags, __entry->node) | |
352 | ); | |
353 | ||
354 | FTRACE_ENTRY(kmem_free, kmemtrace_free_entry, | |
355 | ||
356 | TRACE_KMEM_FREE, | |
357 | ||
358 | F_STRUCT( | |
359 | __field( enum kmemtrace_type_id, type_id ) | |
360 | __field( unsigned long, call_site ) | |
361 | __field( const void *, ptr ) | |
362 | ), | |
363 | ||
364 | F_printk("type:%u call_site:%lx ptr:%p", | |
365 | __entry->type_id, __entry->call_site, __entry->ptr) | |
366 | ); | |
0f8f86c7 FW |
367 | |
368 | FTRACE_ENTRY(ksym_trace, ksym_trace_entry, | |
369 | ||
370 | TRACE_KSYM, | |
371 | ||
372 | F_STRUCT( | |
373 | __field( unsigned long, ip ) | |
374 | __field( unsigned char, type ) | |
0f8f86c7 | 375 | __array( char , cmd, TASK_COMM_LEN ) |
24f1e32c | 376 | __field( unsigned long, addr ) |
0f8f86c7 FW |
377 | ), |
378 | ||
24f1e32c | 379 | F_printk("ip: %pF type: %d ksym_name: %pS cmd: %s", |
0f8f86c7 | 380 | (void *)__entry->ip, (unsigned int)__entry->type, |
24f1e32c | 381 | (void *)__entry->addr, __entry->cmd) |
0f8f86c7 | 382 | ); |