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