2 #define TRACE_SYSTEM timer
4 #if !defined(_TRACE_TIMER_H) || defined(TRACE_HEADER_MULTI_READ)
7 #include <linux/tracepoint.h>
8 #include <linux/hrtimer.h>
9 #include <linux/timer.h>
11 DECLARE_EVENT_CLASS(timer_class,
13 TP_PROTO(struct timer_list *timer),
18 __field( void *, timer )
22 __entry->timer = timer;
25 TP_printk("timer=%p", __entry->timer)
29 * timer_init - called when the timer is initialized
30 * @timer: pointer to struct timer_list
32 DEFINE_EVENT(timer_class, timer_init,
34 TP_PROTO(struct timer_list *timer),
40 * timer_start - called when the timer is started
41 * @timer: pointer to struct timer_list
42 * @expires: the timers expiry time
44 TRACE_EVENT(timer_start,
46 TP_PROTO(struct timer_list *timer,
47 unsigned long expires,
50 TP_ARGS(timer, expires, flags),
53 __field( void *, timer )
54 __field( void *, function )
55 __field( unsigned long, expires )
56 __field( unsigned long, now )
57 __field( unsigned int, flags )
61 __entry->timer = timer;
62 __entry->function = timer->function;
63 __entry->expires = expires;
64 __entry->now = jiffies;
65 __entry->flags = flags;
68 TP_printk("timer=%p function=%pf expires=%lu [timeout=%ld] flags=0x%08x",
69 __entry->timer, __entry->function, __entry->expires,
70 (long)__entry->expires - __entry->now, __entry->flags)
74 * timer_expire_entry - called immediately before the timer callback
75 * @timer: pointer to struct timer_list
77 * Allows to determine the timer latency.
79 TRACE_EVENT(timer_expire_entry,
81 TP_PROTO(struct timer_list *timer),
86 __field( void *, timer )
87 __field( unsigned long, now )
88 __field( void *, function)
92 __entry->timer = timer;
93 __entry->now = jiffies;
94 __entry->function = timer->function;
97 TP_printk("timer=%p function=%pf now=%lu", __entry->timer, __entry->function,__entry->now)
101 * timer_expire_exit - called immediately after the timer callback returns
102 * @timer: pointer to struct timer_list
104 * When used in combination with the timer_expire_entry tracepoint we can
105 * determine the runtime of the timer callback function.
107 * NOTE: Do NOT derefernce timer in TP_fast_assign. The pointer might
108 * be invalid. We solely track the pointer.
110 DEFINE_EVENT(timer_class, timer_expire_exit,
112 TP_PROTO(struct timer_list *timer),
118 * timer_cancel - called when the timer is canceled
119 * @timer: pointer to struct timer_list
121 DEFINE_EVENT(timer_class, timer_cancel,
123 TP_PROTO(struct timer_list *timer),
128 #define decode_clockid(type) \
129 __print_symbolic(type, \
130 { CLOCK_REALTIME, "CLOCK_REALTIME" }, \
131 { CLOCK_MONOTONIC, "CLOCK_MONOTONIC" }, \
132 { CLOCK_BOOTTIME, "CLOCK_BOOTTIME" }, \
133 { CLOCK_TAI, "CLOCK_TAI" })
135 #define decode_hrtimer_mode(mode) \
136 __print_symbolic(mode, \
137 { HRTIMER_MODE_ABS, "ABS" }, \
138 { HRTIMER_MODE_REL, "REL" }, \
139 { HRTIMER_MODE_ABS_PINNED, "ABS|PINNED" }, \
140 { HRTIMER_MODE_REL_PINNED, "REL|PINNED" })
143 * hrtimer_init - called when the hrtimer is initialized
144 * @hrtimer: pointer to struct hrtimer
145 * @clockid: the hrtimers clock
146 * @mode: the hrtimers mode
148 TRACE_EVENT(hrtimer_init,
150 TP_PROTO(struct hrtimer *hrtimer, clockid_t clockid,
151 enum hrtimer_mode mode),
153 TP_ARGS(hrtimer, clockid, mode),
156 __field( void *, hrtimer )
157 __field( clockid_t, clockid )
158 __field( enum hrtimer_mode, mode )
162 __entry->hrtimer = hrtimer;
163 __entry->clockid = clockid;
164 __entry->mode = mode;
167 TP_printk("hrtimer=%p clockid=%s mode=%s", __entry->hrtimer,
168 decode_clockid(__entry->clockid),
169 decode_hrtimer_mode(__entry->mode))
173 * hrtimer_start - called when the hrtimer is started
174 * @hrtimer: pointer to struct hrtimer
176 TRACE_EVENT(hrtimer_start,
178 TP_PROTO(struct hrtimer *hrtimer),
183 __field( void *, hrtimer )
184 __field( void *, function )
185 __field( s64, expires )
186 __field( s64, softexpires )
190 __entry->hrtimer = hrtimer;
191 __entry->function = hrtimer->function;
192 __entry->expires = hrtimer_get_expires(hrtimer).tv64;
193 __entry->softexpires = hrtimer_get_softexpires(hrtimer).tv64;
196 TP_printk("hrtimer=%p function=%pf expires=%llu softexpires=%llu",
197 __entry->hrtimer, __entry->function,
198 (unsigned long long)ktime_to_ns((ktime_t) {
199 .tv64 = __entry->expires }),
200 (unsigned long long)ktime_to_ns((ktime_t) {
201 .tv64 = __entry->softexpires }))
205 * hrtimer_expire_entry - called immediately before the hrtimer callback
206 * @hrtimer: pointer to struct hrtimer
207 * @now: pointer to variable which contains current time of the
210 * Allows to determine the timer latency.
212 TRACE_EVENT(hrtimer_expire_entry,
214 TP_PROTO(struct hrtimer *hrtimer, ktime_t *now),
216 TP_ARGS(hrtimer, now),
219 __field( void *, hrtimer )
221 __field( void *, function)
225 __entry->hrtimer = hrtimer;
226 __entry->now = now->tv64;
227 __entry->function = hrtimer->function;
230 TP_printk("hrtimer=%p function=%pf now=%llu", __entry->hrtimer, __entry->function,
231 (unsigned long long)ktime_to_ns((ktime_t) { .tv64 = __entry->now }))
234 DECLARE_EVENT_CLASS(hrtimer_class,
236 TP_PROTO(struct hrtimer *hrtimer),
241 __field( void *, hrtimer )
245 __entry->hrtimer = hrtimer;
248 TP_printk("hrtimer=%p", __entry->hrtimer)
252 * hrtimer_expire_exit - called immediately after the hrtimer callback returns
253 * @hrtimer: pointer to struct hrtimer
255 * When used in combination with the hrtimer_expire_entry tracepoint we can
256 * determine the runtime of the callback function.
258 DEFINE_EVENT(hrtimer_class, hrtimer_expire_exit,
260 TP_PROTO(struct hrtimer *hrtimer),
266 * hrtimer_cancel - called when the hrtimer is canceled
267 * @hrtimer: pointer to struct hrtimer
269 DEFINE_EVENT(hrtimer_class, hrtimer_cancel,
271 TP_PROTO(struct hrtimer *hrtimer),
277 * itimer_state - called when itimer is started or canceled
278 * @which: name of the interval timer
279 * @value: the itimers value, itimer is canceled if value->it_value is
280 * zero, otherwise it is started
281 * @expires: the itimers expiry time
283 TRACE_EVENT(itimer_state,
285 TP_PROTO(int which, const struct itimerval *const value,
288 TP_ARGS(which, value, expires),
291 __field( int, which )
292 __field( cputime_t, expires )
293 __field( long, value_sec )
294 __field( long, value_usec )
295 __field( long, interval_sec )
296 __field( long, interval_usec )
300 __entry->which = which;
301 __entry->expires = expires;
302 __entry->value_sec = value->it_value.tv_sec;
303 __entry->value_usec = value->it_value.tv_usec;
304 __entry->interval_sec = value->it_interval.tv_sec;
305 __entry->interval_usec = value->it_interval.tv_usec;
308 TP_printk("which=%d expires=%llu it_value=%ld.%ld it_interval=%ld.%ld",
309 __entry->which, (unsigned long long)__entry->expires,
310 __entry->value_sec, __entry->value_usec,
311 __entry->interval_sec, __entry->interval_usec)
315 * itimer_expire - called when itimer expires
316 * @which: type of the interval timer
317 * @pid: pid of the process which owns the timer
318 * @now: current time, used to calculate the latency of itimer
320 TRACE_EVENT(itimer_expire,
322 TP_PROTO(int which, struct pid *pid, cputime_t now),
324 TP_ARGS(which, pid, now),
327 __field( int , which )
328 __field( pid_t, pid )
329 __field( cputime_t, now )
333 __entry->which = which;
335 __entry->pid = pid_nr(pid);
338 TP_printk("which=%d pid=%d now=%llu", __entry->which,
339 (int) __entry->pid, (unsigned long long)__entry->now)
342 #ifdef CONFIG_NO_HZ_COMMON
344 #define TICK_DEP_NAMES \
345 tick_dep_mask_name(NONE) \
346 tick_dep_name(POSIX_TIMER) \
347 tick_dep_name(PERF_EVENTS) \
348 tick_dep_name(SCHED) \
349 tick_dep_name_end(CLOCK_UNSTABLE)
352 #undef tick_dep_mask_name
353 #undef tick_dep_name_end
355 /* The MASK will convert to their bits and they need to be processed too */
356 #define tick_dep_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
357 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
358 #define tick_dep_name_end(sdep) TRACE_DEFINE_ENUM(TICK_DEP_BIT_##sdep); \
359 TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
360 /* NONE only has a mask defined for it */
361 #define tick_dep_mask_name(sdep) TRACE_DEFINE_ENUM(TICK_DEP_MASK_##sdep);
366 #undef tick_dep_mask_name
367 #undef tick_dep_name_end
369 #define tick_dep_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
370 #define tick_dep_mask_name(sdep) { TICK_DEP_MASK_##sdep, #sdep },
371 #define tick_dep_name_end(sdep) { TICK_DEP_MASK_##sdep, #sdep }
373 #define show_tick_dep_name(val) \
374 __print_symbolic(val, TICK_DEP_NAMES)
376 TRACE_EVENT(tick_stop,
378 TP_PROTO(int success, int dependency),
380 TP_ARGS(success, dependency),
383 __field( int , success )
384 __field( int , dependency )
388 __entry->success = success;
389 __entry->dependency = dependency;
392 TP_printk("success=%d dependency=%s", __entry->success, \
393 show_tick_dep_name(__entry->dependency))
397 #endif /* _TRACE_TIMER_H */
399 /* This part must be outside protection */
400 #include <trace/define_trace.h>