1 /* SPDX-License-Identifier: GPL-2.0 */
3 #define TRACE_SYSTEM timer
5 #if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
8 #include <linux/tracepoint.h>
9 #include <linux/hrtimer.h>
10 #include <linux/timer.h>
12 DECLARE_EVENT_CLASS(timer_class,
14 TP_PROTO(struct timer_list *timer),
19 __field( void *, timer )
23 __entry->timer = timer;
26 TP_printk("timer=%p", __entry->timer)
30 * timer_init - called when the timer is initialized
31 * @timer: pointer to struct timer_list
33 DEFINE_EVENT(timer_class, timer_init,
35 TP_PROTO(struct timer_list *timer),
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" })
48 * timer_start - called when the timer is started
49 * @timer: pointer to struct timer_list
50 * @expires: the timers expiry time
52 TRACE_EVENT(timer_start,
54 TP_PROTO(struct timer_list *timer,
55 unsigned long expires,
58 TP_ARGS(timer, expires, flags),
61 __field( void *, timer )
62 __field( void *, function )
63 __field( unsigned long, expires )
64 __field( unsigned long, now )
65 __field( unsigned int, flags )
69 __entry->timer = timer;
70 __entry->function = timer->function;
71 __entry->expires = expires;
72 __entry->now = jiffies;
73 __entry->flags = flags;
76 TP_printk("timer=%p function=%pf 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))
85 * timer_expire_entry - called immediately before the timer callback
86 * @timer: pointer to struct timer_list
88 * Allows to determine the timer latency.
90 TRACE_EVENT(timer_expire_entry,
92 TP_PROTO(struct timer_list *timer),
97 __field( void *, timer )
98 __field( unsigned long, now )
99 __field( void *, function)
103 __entry->timer = timer;
104 __entry->now = jiffies;
105 __entry->function = timer->function;
108 TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now)
112 * timer_expire_exit - called immediately after the timer callback returns
113 * @timer: pointer to struct timer_list
115 * When used in combination with the timer_expire_entry tracepoint we can
116 * determine the runtime of the timer callback function.
118 * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
119 * be invalid. We solely track the pointer.
121 DEFINE_EVENT(timer_class, timer_expire_exit,
123 TP_PROTO(struct timer_list *timer),
129 * timer_cancel - called when the timer is canceled
130 * @timer: pointer to struct timer_list
132 DEFINE_EVENT(timer_class, timer_cancel,
134 TP_PROTO(struct timer_list *timer),
139 #define decode_clockid(type) \
140 __print_symbolic(type, \
141 { CLOCK_REALTIME, "CLOCK_REALTIME" }, \
142 { CLOCK_MONOTONIC, "CLOCK_MONOTONIC" }, \
143 { CLOCK_BOOTTIME, "CLOCK_BOOTTIME" }, \
144 { CLOCK_TAI, "CLOCK_TAI" })
146 #define decode_hrtimer_mode(mode) \
147 __print_symbolic(mode, \
148 { HRTIMER_MODE_ABS, "ABS" }, \
149 { HRTIMER_MODE_REL, "REL" }, \
150 { HRTIMER_MODE_ABS_PINNED, "ABS|PINNED" }, \
151 { HRTIMER_MODE_REL_PINNED, "REL|PINNED" })
154 * hrtimer_init - called when the hrtimer is initialized
155 * @hrtimer: pointer to struct hrtimer
156 * @clockid: the hrtimers clock
157 * @mode: the hrtimers mode
159 TRACE_EVENT(hrtimer_init,
161 TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid,
162 enum hrtimer_mode mode),
164 TP_ARGS(hrtimer, clockid, mode),
167 __field( void *, hrtimer )
168 __field( clockid_t, clockid )
169 __field( enum hrtimer_mode, mode )
173 __entry->hrtimer = hrtimer;
174 __entry->clockid = clockid;
175 __entry->mode = mode;
178 TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer,
179 decode_clockid(__entry->clockid),
180 decode_hrtimer_mode(__entry->mode))
184 * hrtimer_start - called when the hrtimer is started
185 * @hrtimer: pointer to struct hrtimer
187 TRACE_EVENT(hrtimer_start,
189 TP_PROTO(struct hrtimer *hrtimer),
194 __field( void *, hrtimer )
195 __field( void *, function )
196 __field( s64, expires )
197 __field( s64, softexpires )
201 __entry->hrtimer = hrtimer;
202 __entry->function = hrtimer->function;
203 __entry->expires = hrtimer_get_expires(hrtimer);
204 __entry->softexpires = hrtimer_get_softexpires(hrtimer);
207 TP_printk("hrtimer=%p function=%pf expires=%llu softexpires=%llu",
208 __entry->hrtimer, __entry->function,
209 (unsigned long long) __entry->expires,
210 (unsigned long long) __entry->softexpires)
214 * hrtimer_expire_entry - called immediately before the hrtimer callback
215 * @hrtimer: pointer to struct hrtimer
216 * @now: pointer to variable which contains current time of the
219 * Allows to determine the timer latency.
221 TRACE_EVENT(hrtimer_expire_entry,
223 TP_PROTO(struct hrtimer *hrtimer, ktime_t *now),
225 TP_ARGS(hrtimer, now),
228 __field( void *, hrtimer )
230 __field( void *, function)
234 __entry->hrtimer = hrtimer;
236 __entry->function = hrtimer->function;
239 TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
240 (unsigned long long) __entry->now)
243 DECLARE_EVENT_CLASS(hrtimer_class,
245 TP_PROTO(struct hrtimer *hrtimer),
250 __field( void *, hrtimer )
254 __entry->hrtimer = hrtimer;
257 TP_printk("hrtimer=%p", __entry->hrtimer)
261 * hrtimer_expire_exit - called immediately after the hrtimer callback returns
262 * @hrtimer: pointer to struct hrtimer
264 * When used in combination with the hrtimer_expire_entry tracepoint we can
265 * determine the runtime of the callback function.
267 DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit,
269 TP_PROTO(struct hrtimer *hrtimer),
275 * hrtimer_cancel - called when the hrtimer is canceled
276 * @hrtimer: pointer to struct hrtimer
278 DEFINE_EVENT(hrtimer_class, hrtimer_cancel,
280 TP_PROTO(struct hrtimer *hrtimer),
286 * itimer_state - called when itimer is started or canceled
287 * @which: name of the interval timer
288 * @value: the itimers value, itimer is canceled if value->it_value is
289 * zero, otherwise it is started
290 * @expires: the itimers expiry time
292 TRACE_EVENT(itimer_state,
294 TP_PROTO(int which, const struct itimerval *const value,
295 unsigned long long expires),
297 TP_ARGS(which, value, expires),
300 __field( int, which )
301 __field( unsigned long long, expires )
302 __field( long, value_sec )
303 __field( long, value_usec )
304 __field( long, interval_sec )
305 __field( long, interval_usec )
309 __entry->which = which;
310 __entry->expires = expires;
311 __entry->value_sec = value->it_value.tv_sec;
312 __entry->value_usec = value->it_value.tv_usec;
313 __entry->interval_sec = value->it_interval.tv_sec;
314 __entry->interval_usec = value->it_interval.tv_usec;
317 TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld",
318 __entry->which, __entry->expires,
319 __entry->value_sec, __entry->value_usec,
320 __entry->interval_sec, __entry->interval_usec)
324 * itimer_expire - called when itimer expires
325 * @which: type of the interval timer
326 * @pid: pid of the process which owns the timer
327 * @now: current time, used to calculate the latency of itimer
329 TRACE_EVENT(itimer_expire,
331 TP_PROTO(int which, struct pid *pid, unsigned long long now),
333 TP_ARGS(which, pid, now),
336 __field( int , which )
337 __field( pid_t, pid )
338 __field( unsigned long long, now )
342 __entry->which = which;
344 __entry->pid = pid_nr(pid);
347 TP_printk("which=%d pid=%d now=%llu", __entry->which,
348 (int) __entry->pid, __entry->now)
351 #ifdef CONFIG_NO_HZ_COMMON
353 #define TICK_DEP_NAMES \
354 tick_dep_mask_name(NONE) \
355 tick_dep_name(POSIX_TIMER) \
356 tick_dep_name(PERF_EVENTS) \
357 tick_dep_name(SCHED) \
358 tick_dep_name_end(CLOCK_UNSTABLE)
361 #undef tick_dep_mask_name
362 #undef tick_dep_name_end
364 /* The MASK will convert to their bits and they need to be processed too */
365 #define tick_dep_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
366 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
367 #define tick_dep_name_end(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
368 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
369 /* NONE only has a mask defined for it */
370 #define tick_dep_mask_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
375 #undef tick_dep_mask_name
376 #undef tick_dep_name_end
378 #define tick_dep_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
379 #define tick_dep_mask_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
380 #define tick_dep_name_end(sdep) { TICK_DEP_MASK_##sdep, #sdep }
382 #define show_tick_dep_name(val) \
383 __print_symbolic(val, TICK_DEP_NAMES)
385 TRACE_EVENT(tick_stop,
387 TP_PROTO(int success, int dependency),
389 TP_ARGS(success, dependency),
392 __field( int , success )
393 __field( int , dependency )
397 __entry->success = success;
398 __entry->dependency = dependency;
401 TP_printk("success=%d dependency=%s", __entry->success, \
402 show_tick_dep_name(__entry->dependency))
406 #endif /* _TRACE_TIMER_H */
408 /* This part must be outside protection */
409 #include <trace/define_trace.h>