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