Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #undef TRACE_SYSTEM
3 : : #define TRACE_SYSTEM timer
4 : :
5 : : #if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
6 : : #define _TRACE_TIMER_H
7 : :
8 : : #include <linux/tracepoint.h>
9 : : #include <linux/hrtimer.h>
10 : : #include <linux/timer.h>
11 : :
12 : 3 : DECLARE_EVENT_CLASS(timer_class,
13 : :
14 : : TP_PROTO(struct timer_list *timer),
15 : :
16 : : TP_ARGS(timer),
17 : :
18 : : TP_STRUCT__entry(
19 : : __field( void *, timer )
20 : : ),
21 : :
22 : : TP_fast_assign(
23 : : __entry->timer = timer;
24 : : ),
25 : :
26 : : TP_printk("timer=%p", __entry->timer)
27 : : );
28 : :
29 : : /**
30 : : * timer_init - called when the timer is initialized
31 : : * @timer: pointer to struct timer_list
32 : : */
33 : 3 : DEFINE_EVENT(timer_class, timer_init,
34 : :
35 : : TP_PROTO(struct timer_list *timer),
36 : :
37 : : TP_ARGS(timer)
38 : : );
39 : :
40 : : #define decode_timer_flags(flags) \
41 : : __print_flags(flags, "|", \
42 : : { TIMER_MIGRATING, "M" }, \
43 : : { TIMER_DEFERRABLE, "D" }, \
44 : : { TIMER_PINNED, "P" }, \
45 : : { TIMER_IRQSAFE, "I" })
46 : :
47 : : /**
48 : : * timer_start - called when the timer is started
49 : : * @timer: pointer to struct timer_list
50 : : * @expires: the timers expiry time
51 : : */
52 : 3 : TRACE_EVENT(timer_start,
53 : :
54 : : TP_PROTO(struct timer_list *timer,
55 : : unsigned long expires,
56 : : unsigned int flags),
57 : :
58 : : TP_ARGS(timer, expires, flags),
59 : :
60 : : TP_STRUCT__entry(
61 : : __field( void *, timer )
62 : : __field( void *, function )
63 : : __field( unsigned long, expires )
64 : : __field( unsigned long, now )
65 : : __field( unsigned int, flags )
66 : : ),
67 : :
68 : : TP_fast_assign(
69 : : __entry->timer = timer;
70 : : __entry->function = timer->function;
71 : : __entry->expires = expires;
72 : : __entry->now = jiffies;
73 : : __entry->flags = flags;
74 : : ),
75 : :
76 : : TP_printk("timer=%p function=%ps expires=%lu [timeout=%ld] cpu=%u idx=%u flags=%s",
77 : : __entry->timer, __entry->function, __entry->expires,
78 : : (long)__entry->expires - __entry->now,
79 : : __entry->flags & TIMER_CPUMASK,
80 : : __entry->flags >> TIMER_ARRAYSHIFT,
81 : : decode_timer_flags(__entry->flags & TIMER_TRACE_FLAGMASK))
82 : : );
83 : :
84 : : /**
85 : : * timer_expire_entry - called immediately before the timer callback
86 : : * @timer: pointer to struct timer_list
87 : : *
88 : : * Allows to determine the timer latency.
89 : : */
90 : 3 : TRACE_EVENT(timer_expire_entry,
91 : :
92 : : TP_PROTO(struct timer_list *timer, unsigned long baseclk),
93 : :
94 : : TP_ARGS(timer, baseclk),
95 : :
96 : : TP_STRUCT__entry(
97 : : __field( void *, timer )
98 : : __field( unsigned long, now )
99 : : __field( void *, function)
100 : : __field( unsigned long, baseclk )
101 : : ),
102 : :
103 : : TP_fast_assign(
104 : : __entry->timer = timer;
105 : : __entry->now = jiffies;
106 : : __entry->function = timer->function;
107 : : __entry->baseclk = baseclk;
108 : : ),
109 : :
110 : : TP_printk("timer=%p function=%ps now=%lu baseclk=%lu",
111 : : __entry->timer, __entry->function, __entry->now,
112 : : __entry->baseclk)
113 : : );
114 : :
115 : : /**
116 : : * timer_expire_exit - called immediately after the timer callback returns
117 : : * @timer: pointer to struct timer_list
118 : : *
119 : : * When used in combination with the timer_expire_entry tracepoint we can
120 : : * determine the runtime of the timer callback function.
121 : : *
122 : : * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
123 : : * be invalid. We solely track the pointer.
124 : : */
125 : 3 : DEFINE_EVENT(timer_class, timer_expire_exit,
126 : :
127 : : TP_PROTO(struct timer_list *timer),
128 : :
129 : : TP_ARGS(timer)
130 : : );
131 : :
132 : : /**
133 : : * timer_cancel - called when the timer is canceled
134 : : * @timer: pointer to struct timer_list
135 : : */
136 : 3 : DEFINE_EVENT(timer_class, timer_cancel,
137 : :
138 : : TP_PROTO(struct timer_list *timer),
139 : :
140 : : TP_ARGS(timer)
141 : : );
142 : :
143 : : #define decode_clockid(type) \
144 : : __print_symbolic(type, \
145 : : { CLOCK_REALTIME, "CLOCK_REALTIME" }, \
146 : : { CLOCK_MONOTONIC, "CLOCK_MONOTONIC" }, \
147 : : { CLOCK_BOOTTIME, "CLOCK_BOOTTIME" }, \
148 : : { CLOCK_TAI, "CLOCK_TAI" })
149 : :
150 : : #define decode_hrtimer_mode(mode) \
151 : : __print_symbolic(mode, \
152 : : { HRTIMER_MODE_ABS, "ABS" }, \
153 : : { HRTIMER_MODE_REL, "REL" }, \
154 : : { HRTIMER_MODE_ABS_PINNED, "ABS|PINNED" }, \
155 : : { HRTIMER_MODE_REL_PINNED, "REL|PINNED" }, \
156 : : { HRTIMER_MODE_ABS_SOFT, "ABS|SOFT" }, \
157 : : { HRTIMER_MODE_REL_SOFT, "REL|SOFT" }, \
158 : : { HRTIMER_MODE_ABS_PINNED_SOFT, "ABS|PINNED|SOFT" }, \
159 : : { HRTIMER_MODE_REL_PINNED_SOFT, "REL|PINNED|SOFT" })
160 : :
161 : : /**
162 : : * hrtimer_init - called when the hrtimer is initialized
163 : : * @hrtimer: pointer to struct hrtimer
164 : : * @clockid: the hrtimers clock
165 : : * @mode: the hrtimers mode
166 : : */
167 : 3 : TRACE_EVENT(hrtimer_init,
168 : :
169 : : TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid,
170 : : enum hrtimer_mode mode),
171 : :
172 : : TP_ARGS(hrtimer, clockid, mode),
173 : :
174 : : TP_STRUCT__entry(
175 : : __field( void *, hrtimer )
176 : : __field( clockid_t, clockid )
177 : : __field( enum hrtimer_mode, mode )
178 : : ),
179 : :
180 : : TP_fast_assign(
181 : : __entry->hrtimer = hrtimer;
182 : : __entry->clockid = clockid;
183 : : __entry->mode = mode;
184 : : ),
185 : :
186 : : TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer,
187 : : decode_clockid(__entry->clockid),
188 : : decode_hrtimer_mode(__entry->mode))
189 : : );
190 : :
191 : : /**
192 : : * hrtimer_start - called when the hrtimer is started
193 : : * @hrtimer: pointer to struct hrtimer
194 : : */
195 : 3 : TRACE_EVENT(hrtimer_start,
196 : :
197 : : TP_PROTO(struct hrtimer *hrtimer, enum hrtimer_mode mode),
198 : :
199 : : TP_ARGS(hrtimer, mode),
200 : :
201 : : TP_STRUCT__entry(
202 : : __field( void *, hrtimer )
203 : : __field( void *, function )
204 : : __field( s64, expires )
205 : : __field( s64, softexpires )
206 : : __field( enum hrtimer_mode, mode )
207 : : ),
208 : :
209 : : TP_fast_assign(
210 : : __entry->hrtimer = hrtimer;
211 : : __entry->function = hrtimer->function;
212 : : __entry->expires = hrtimer_get_expires(hrtimer);
213 : : __entry->softexpires = hrtimer_get_softexpires(hrtimer);
214 : : __entry->mode = mode;
215 : : ),
216 : :
217 : : TP_printk("hrtimer=%p function=%ps expires=%llu softexpires=%llu "
218 : : "mode=%s", __entry->hrtimer, __entry->function,
219 : : (unsigned long long) __entry->expires,
220 : : (unsigned long long) __entry->softexpires,
221 : : decode_hrtimer_mode(__entry->mode))
222 : : );
223 : :
224 : : /**
225 : : * hrtimer_expire_entry - called immediately before the hrtimer callback
226 : : * @hrtimer: pointer to struct hrtimer
227 : : * @now: pointer to variable which contains current time of the
228 : : * timers base.
229 : : *
230 : : * Allows to determine the timer latency.
231 : : */
232 : 3 : TRACE_EVENT(hrtimer_expire_entry,
233 : :
234 : : TP_PROTO(struct hrtimer *hrtimer, ktime_t *now),
235 : :
236 : : TP_ARGS(hrtimer, now),
237 : :
238 : : TP_STRUCT__entry(
239 : : __field( void *, hrtimer )
240 : : __field( s64, now )
241 : : __field( void *, function)
242 : : ),
243 : :
244 : : TP_fast_assign(
245 : : __entry->hrtimer = hrtimer;
246 : : __entry->now = *now;
247 : : __entry->function = hrtimer->function;
248 : : ),
249 : :
250 : : TP_printk("hrtimer=%p function=%ps now=%llu",
251 : : __entry->hrtimer, __entry->function,
252 : : (unsigned long long) __entry->now)
253 : : );
254 : :
255 : 3 : DECLARE_EVENT_CLASS(hrtimer_class,
256 : :
257 : : TP_PROTO(struct hrtimer *hrtimer),
258 : :
259 : : TP_ARGS(hrtimer),
260 : :
261 : : TP_STRUCT__entry(
262 : : __field( void *, hrtimer )
263 : : ),
264 : :
265 : : TP_fast_assign(
266 : : __entry->hrtimer = hrtimer;
267 : : ),
268 : :
269 : : TP_printk("hrtimer=%p", __entry->hrtimer)
270 : : );
271 : :
272 : : /**
273 : : * hrtimer_expire_exit - called immediately after the hrtimer callback returns
274 : : * @hrtimer: pointer to struct hrtimer
275 : : *
276 : : * When used in combination with the hrtimer_expire_entry tracepoint we can
277 : : * determine the runtime of the callback function.
278 : : */
279 : 3 : DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit,
280 : :
281 : : TP_PROTO(struct hrtimer *hrtimer),
282 : :
283 : : TP_ARGS(hrtimer)
284 : : );
285 : :
286 : : /**
287 : : * hrtimer_cancel - called when the hrtimer is canceled
288 : : * @hrtimer: pointer to struct hrtimer
289 : : */
290 : 3 : DEFINE_EVENT(hrtimer_class, hrtimer_cancel,
291 : :
292 : : TP_PROTO(struct hrtimer *hrtimer),
293 : :
294 : : TP_ARGS(hrtimer)
295 : : );
296 : :
297 : : /**
298 : : * itimer_state - called when itimer is started or canceled
299 : : * @which: name of the interval timer
300 : : * @value: the itimers value, itimer is canceled if value->it_value is
301 : : * zero, otherwise it is started
302 : : * @expires: the itimers expiry time
303 : : */
304 : 3 : TRACE_EVENT(itimer_state,
305 : :
306 : : TP_PROTO(int which, const struct itimerval *const value,
307 : : unsigned long long expires),
308 : :
309 : : TP_ARGS(which, value, expires),
310 : :
311 : : TP_STRUCT__entry(
312 : : __field( int, which )
313 : : __field( unsigned long long, expires )
314 : : __field( long, value_sec )
315 : : __field( long, value_usec )
316 : : __field( long, interval_sec )
317 : : __field( long, interval_usec )
318 : : ),
319 : :
320 : : TP_fast_assign(
321 : : __entry->which = which;
322 : : __entry->expires = expires;
323 : : __entry->value_sec = value->it_value.tv_sec;
324 : : __entry->value_usec = value->it_value.tv_usec;
325 : : __entry->interval_sec = value->it_interval.tv_sec;
326 : : __entry->interval_usec = value->it_interval.tv_usec;
327 : : ),
328 : :
329 : : TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld",
330 : : __entry->which, __entry->expires,
331 : : __entry->value_sec, __entry->value_usec,
332 : : __entry->interval_sec, __entry->interval_usec)
333 : : );
334 : :
335 : : /**
336 : : * itimer_expire - called when itimer expires
337 : : * @which: type of the interval timer
338 : : * @pid: pid of the process which owns the timer
339 : : * @now: current time, used to calculate the latency of itimer
340 : : */
341 : 3 : TRACE_EVENT(itimer_expire,
342 : :
343 : : TP_PROTO(int which, struct pid *pid, unsigned long long now),
344 : :
345 : : TP_ARGS(which, pid, now),
346 : :
347 : : TP_STRUCT__entry(
348 : : __field( int , which )
349 : : __field( pid_t, pid )
350 : : __field( unsigned long long, now )
351 : : ),
352 : :
353 : : TP_fast_assign(
354 : : __entry->which = which;
355 : : __entry->now = now;
356 : : __entry->pid = pid_nr(pid);
357 : : ),
358 : :
359 : : TP_printk("which=%d pid=%d now=%llu", __entry->which,
360 : : (int) __entry->pid, __entry->now)
361 : : );
362 : :
363 : : #ifdef CONFIG_NO_HZ_COMMON
364 : :
365 : : #define TICK_DEP_NAMES \
366 : : tick_dep_mask_name(NONE) \
367 : : tick_dep_name(POSIX_TIMER) \
368 : : tick_dep_name(PERF_EVENTS) \
369 : : tick_dep_name(SCHED) \
370 : : tick_dep_name_end(CLOCK_UNSTABLE)
371 : :
372 : : #undef tick_dep_name
373 : : #undef tick_dep_mask_name
374 : : #undef tick_dep_name_end
375 : :
376 : : /* The MASK will convert to their bits and they need to be processed too */
377 : : #define tick_dep_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
378 : : TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
379 : : #define tick_dep_name_end(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
380 : : TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
381 : : /* NONE only has a mask defined for it */
382 : : #define tick_dep_mask_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
383 : :
384 : : TICK_DEP_NAMES
385 : :
386 : : #undef tick_dep_name
387 : : #undef tick_dep_mask_name
388 : : #undef tick_dep_name_end
389 : :
390 : : #define tick_dep_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
391 : : #define tick_dep_mask_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
392 : : #define tick_dep_name_end(sdep) { TICK_DEP_MASK_##sdep, #sdep }
393 : :
394 : : #define show_tick_dep_name(val) \
395 : : __print_symbolic(val, TICK_DEP_NAMES)
396 : :
397 : 3 : TRACE_EVENT(tick_stop,
398 : :
399 : : TP_PROTO(int success, int dependency),
400 : :
401 : : TP_ARGS(success, dependency),
402 : :
403 : : TP_STRUCT__entry(
404 : : __field( int , success )
405 : : __field( int , dependency )
406 : : ),
407 : :
408 : : TP_fast_assign(
409 : : __entry->success = success;
410 : : __entry->dependency = dependency;
411 : : ),
412 : :
413 : : TP_printk("success=%d dependency=%s", __entry->success, \
414 : : show_tick_dep_name(__entry->dependency))
415 : : );
416 : : #endif
417 : :
418 : : #endif /* _TRACE_TIMER_H */
419 : :
420 : : /* This part must be outside protection */
421 : : #include <trace/define_trace.h>
|
