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